cgi-files/lib/database.lib

   1 #################################################################################
   2 # database.lib: Kiriwrite Database 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 ($form_data->{'action'}){
  11         # An action has been specified, so find out what action has been specified.
  12
  13         my $http_query_action = $form_data->{'action'};
  14
  15         if ($http_query_action eq "edit"){
  16                 # The edit action (which mean edit the settings for the selected database) has been specified,
  17                 # get the database name and check if the action to edit an database has been confirmed.
  18
  19                 if ($form_data->{'database'}){
  20                         # If there is a value in the database variable check if it is a valid database. Otherwise,
  21                         # return an error.
  22
  23                         my $http_query_database = $form_data->{'database'};
  24
  25                         # Check if a value for confirm has been specified, if there is, check if it is the correct
  26                         # value, otherwise return an error.
  27
  28                         if ($form_data->{'confirm'}){
  29                                 # A value for confirm has been specified, find out what value it is. If the value is correct
  30                                 # then edit the database settings, otherwise return an error.
  31
  32                                 my $http_query_confirm = $form_data->{'confirm'};
  33
  34                                 if ($http_query_confirm eq 1){
  35                                         # Value is correct, collect the variables to pass onto the database variable.
  36
  37                                         # Get the variables from the HTTP query.
  38
  39                                         my $newdatabasename             = $form_data->{'databasename'};
  40                                         my $newdatabasedescription      = $form_data->{'databasedescription'};
  41                                         my $newdatabasefilename         = $form_data->{'databasefilename'};
  42                                         my $databaseshortname           = $form_data->{'database'};
  43                                         my $databasenotes               = $form_data->{'databasenotes'};
  44                                         my $databasecategories          = $form_data->{'databasecategories'};
  45
  46                                         # Pass the variables to the database editing subroutine.
  47
  48                                         my $pagedata = kiriwrite_database_edit($databaseshortname, $newdatabasefilename, $newdatabasename, $newdatabasedescription, $databasenotes, $databasecategories, 1);
  49
  50                                         kiriwrite_output_header;
  51                                         kiriwrite_output_page($kiriwrite_lang->{database}->{editdatabasetitle}, $pagedata, "database");
  52                                         exit;
  53
  54                                 } else {
  55                                         # Value is incorrect, return and error.
  56                                         kiriwrite_error("invalidvariable");
  57                                 }
  58
  59                         }
  60
  61                         # Display the form for editing an database.
  62                         my $pagedata = kiriwrite_database_edit($http_query_database);
  63
  64                         kiriwrite_output_header;
  65                         kiriwrite_output_page($kiriwrite_lang->{database}->{editdatabasetitle}, $pagedata, "database");
  66                         exit;
  67
  68                 } else {
  69
  70                         # If there is no value in the database variable, then return an error.
  71                         kiriwrite_error("invalidvariable");
  72
  73                 }
  74
  75         } elsif ($http_query_action eq "delete"){
  76
  77                 # Action equested is to delete a database, find out if the user has already confirmed deletion of the database
  78                 # and if the deletion of the database has been confirmed, delete the database.
  79
  80                 if ($form_data->{'confirm'}){
  81
  82                         # User has confirmed to delete a database, pass the parameters to the kiriwrite_database_delete
  83                         # subroutine.
  84
  85                         my $database_filename   = $form_data->{'database'};
  86                         my $database_confirm    = $form_data->{'confirm'};
  87                         my $pagedata = kiriwrite_database_delete($database_filename, $database_confirm);
  88
  89                         kiriwrite_output_header;
  90                         kiriwrite_output_page($kiriwrite_lang->{database}->{deleteddatabase}, $pagedata, "database");
  91
  92                         exit;
  93
  94                 }
  95
  96                 # User has clicked on the delete link (thus hasn't confirmed the action to delete a database).
  97
  98                 my $database_filename = $form_data->{'database'};
  99                 my $pagedata = kiriwrite_database_delete($database_filename);
 100
 101                 kiriwrite_output_header;
 102                 kiriwrite_output_page($kiriwrite_lang->{database}->{deletedatabase}, $pagedata, "database");
 103
 104                 exit;
 105
 106         } elsif ($http_query_action eq "new"){
 107
 108                 # Action requested is to create a new database, find out if the user has already entered the information needed
 109                 # to create a database and see if the user has confirmed the action, otherwise printout a form for adding a
 110                 # database.
 111
 112                 my $http_query_confirm = $form_data->{'confirm'};
 113
 114                 # Check if the confirm value is correct.
 115
 116                 if ($http_query_confirm){
 117                         if ($http_query_confirm eq 1){
 118
 119                                 # User has confirmed to create a database, pass the parameters to the
 120                                 # kiriwrite_database_add subroutine.
 121
 122                                 my $http_query_confirm = $form_data->{'confirm'};
 123
 124                                 my $database_name               = $form_data->{'databasename'};
 125                                 my $database_description        = $form_data->{'databasedescription'};
 126                                 my $database_filename           = $form_data->{'databasefilename'};
 127                                 my $database_notes              = $form_data->{'databasenotes'};
 128                                 my $database_categories         = $form_data->{'databasecategories'};
 129
 130                                 my $pagedata = kiriwrite_database_add($database_filename, $database_name, $database_description, $database_notes, $database_categories, $http_query_confirm);
 131
 132                                 kiriwrite_output_header;
 133                                 kiriwrite_output_page($kiriwrite_lang->{database}->{adddatabase}, $pagedata, "database");
 134                                 exit;
 135
 136                         } else {
 137
 138                                 # The confirm value is something else other than 1 (which it shouldn't be), so
 139                                 # return an error.
 140
 141                         }
 142                 }
 143
 144                 # User has clicked on the 'Add Database' link.
 145
 146                 my $pagedata = kiriwrite_database_add();
 147
 148                 kiriwrite_output_header;
 149                 kiriwrite_output_page($kiriwrite_lang->{database}->{adddatabase}, $pagedata, "database");
 150                 exit;
 151
 152         } else {
 153                 # Another option has been specified, so return an error.
 154
 155                 kiriwrite_error("invalidaction");
 156         }
 157 }
 158
 159 # No action has been specified, do the default action of displaying a list
 160 # of databases.
 161
 162 my $pagedata = kiriwrite_database_list();
 163
 164 kiriwrite_output_header;                # Output the header to browser/console/stdout.
 165 kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
 166 exit;                                   # End the script.
 167
 168 #################################################################################
 169 # Begin list of relevant subroutines.                                           #
 170 #################################################################################
 171
 172 sub kiriwrite_database_add{
 173 #################################################################################
 174 # kiriwrite_database_add: Creates a new database.                               #
 175 #                                                                               #
 176 # Usage:                                                                        #
 177 #                                                                               #
 178 # kiriwrite_database_add(filename, name, description, notes, categories,        #
 179 #                               [confirm]);                                     #
 180 #                                                                               #
 181 # filename      Specifies the filename for the database.                        #
 182 # name          Specifies a (friendly) name for the database.                   #
 183 # description   Specifies a description for the database.                       #
 184 # notes         Specifies the notes for the database.                           #
 185 # categories    Specifies the categories for the database.                      #
 186 # confirm       Confirms the action to create a database.                       #
 187 #################################################################################
 188
 189         # Get the variables passed from the subroutine.
 190
 191         my ($database_filename, $database_name, $database_description, $database_notes, $database_categories, $database_confirm) = @_;
 192
 193         # Check if the confirm value is blank and if it is then
 194         # set the confirm value to 0.
 195
 196         if (!$database_confirm){
 197
 198                 # The confirm value was blank so set the value to 0.
 199
 200                 $database_confirm = 0;
 201
 202         }
 203
 204         if ($database_confirm eq 1){
 205
 206                 # The action to create a new database is confirmed.
 207
 208                 # Validate the database name and database descriptions.
 209
 210                 my $database_name_check_utf8            = kiriwrite_variablecheck($database_name, "utf8", 0, 0);
 211                 my $database_description_check_utf8     = kiriwrite_variablecheck($database_description, "utf8", 0, 0);
 212                 my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
 213                 my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
 214
 215                 # Convert the UTF8 strings before checking the length of the strings.
 216
 217                 $database_name                  = kiriwrite_utf8convert($database_name);
 218                 $database_description           = kiriwrite_utf8convert($database_description);
 219                 $database_notes                 = kiriwrite_utf8convert($database_notes);
 220                 $database_categories            = kiriwrite_utf8convert($database_categories);
 221
 222                 my $database_name_check_blank           = kiriwrite_variablecheck($database_name, "blank", 0, 1);
 223                 my $database_name_check_length          = kiriwrite_variablecheck($database_name, "maxlength", 256, 1);
 224                 my $database_description_check_length   = kiriwrite_variablecheck($database_description, "maxlength", 512, 1);
 225                 my $database_filename_check_length      = kiriwrite_variablecheck($database_filename, "maxlength", 32, 1);
 226                 my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
 227
 228                 # Check if values returned contains any values that would
 229                 # result in a specific error message being returned.
 230
 231                 if ($database_name_check_length eq 1){
 232
 233                         # The length of the database name is too long, so return an error.
 234                         kiriwrite_error("databasenametoolong");
 235
 236                 }
 237
 238                 if ($database_description_check_length eq 1){
 239
 240                         # The database description length is too long, so return an error.
 241                         kiriwrite_error("databasedescriptiontoolong");
 242
 243                 }
 244
 245                 if ($database_name_check_blank eq 1){
 246
 247                         # The database name is blank, so return an error.
 248                         kiriwrite_error("databasenameblank");
 249
 250                 }
 251
 252                 if ($database_filename_check_length eq 1){
 253
 254                         # The database filename is to long, so return an error.
 255                         kiriwrite_error("databasefilenametoolong");
 256
 257                 }
 258
 259                 if ($database_categories_check_length eq 1){
 260
 261                         # The database categories is too long, so return an error.
 262                         kiriwrite_error("databasecategoriestoolong");
 263
 264                 }
 265
 266                 # Check if the database filename is blank and if it is then
 267                 # generate a filename.
 268
 269                 if ($database_filename eq ""){
 270
 271                         # Filename is blank so generate a file name from
 272                         # the database name.
 273
 274                         $database_filename = kiriwrite_processfilename($database_name);
 275
 276                 } else {
 277
 278                         # Filename is not blank so don't generate a filename.
 279
 280                 }
 281
 282                 kiriwrite_variablecheck($database_filename, "filename", "", 0);
 283                 kiriwrite_variablecheck($database_filename, "maxlength", 32, 0);
 284
 285                 # Connect to the database server.
 286
 287                 $kiriwrite_dbmodule->connect();
 288
 289                 # Check if any errors occured while connecting to the database server.
 290
 291                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 292
 293                         # A database connection error has occured so return
 294                         # an error.
 295
 296                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 297
 298                 }
 299
 300                 my $database_name_final = $database_name;
 301
 302                 # Create the database.
 303
 304                 $kiriwrite_dbmodule->adddatabase({ DatabaseFilename => $database_filename, DatabaseName => $database_name, DatabaseDescription => $database_description, DatabaseNotes => $database_notes, DatabaseCategories => $database_categories, VersionMajor => $kiriwrite_version{"major"}, VersionMinor => $kiriwrite_version{"minor"}, VersionRevision => $kiriwrite_version{"revision"} });
 305
 306                 # Check if any errors have occured.
 307
 308                 if ($kiriwrite_dbmodule->geterror eq "DatabaseExists"){
 309
 310                         # A database with the filename given already exists, so
 311                         # return an error.
 312
 313                         kiriwrite_error("fileexists");
 314
 315                 } elsif ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 316
 317                         # A database error has occured so return an error with
 318                         # the extended error information.
 319
 320                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 321
 322                 }
 323
 324                 # Disconnect from the database server.
 325
 326                 $kiriwrite_dbmodule->disconnect();
 327
 328                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{adddatabase}, { Style => "pageheader" });
 329                 $kiriwrite_presmodule->addlinebreak();
 330                 $kiriwrite_presmodule->addlinebreak();
 331                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{database}->{databaseadded} , $database_name_final));
 332                 $kiriwrite_presmodule->addlinebreak();
 333                 $kiriwrite_presmodule->addlinebreak();
 334                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{databaselistreturnlink} });
 335
 336                 return $kiriwrite_presmodule->grab();
 337
 338         }
 339
 340         # There is confirm value is not 1, so write a form for creating a database to
 341         # store pages in.
 342
 343         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{adddatabase}, { Style => "pageheader" });
 344         $kiriwrite_presmodule->addlinebreak();
 345         $kiriwrite_presmodule->addlinebreak();
 346         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
 347         $kiriwrite_presmodule->startbox();
 348         $kiriwrite_presmodule->addhiddendata("mode", "db");
 349         $kiriwrite_presmodule->addhiddendata("action", "new");
 350         $kiriwrite_presmodule->addhiddendata("confirm", "1");
 351         $kiriwrite_presmodule->endbox();
 352         $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
 353
 354         $kiriwrite_presmodule->startheader();
 355         $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{setting}, { Style => "tablecellheader"});
 356         $kiriwrite_presmodule->addheader($kiriwrite_lang->{common}->{value}, { Style => "tablecellheader"});
 357         $kiriwrite_presmodule->endheader();
 358
 359         $kiriwrite_presmodule->startrow();
 360         $kiriwrite_presmodule->addcell("tablecell1");
 361         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasename});
 362         $kiriwrite_presmodule->endcell();
 363         $kiriwrite_presmodule->addcell("tablecell2");
 364         $kiriwrite_presmodule->addinputbox("databasename", { Size => 64, MaxLength => 256 });
 365         $kiriwrite_presmodule->endcell();
 366         $kiriwrite_presmodule->endrow();
 367
 368         $kiriwrite_presmodule->startrow();
 369         $kiriwrite_presmodule->addcell("tablecell1");
 370         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasedescription});
 371         $kiriwrite_presmodule->endcell();
 372         $kiriwrite_presmodule->addcell("tablecell2");
 373         $kiriwrite_presmodule->addinputbox("databasedescription", { Size => 64, MaxLength => 512 });
 374         $kiriwrite_presmodule->endcell();
 375         $kiriwrite_presmodule->endrow();
 376
 377         $kiriwrite_presmodule->startrow();
 378         $kiriwrite_presmodule->addcell("tablecell1");
 379         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasecategories});
 380         $kiriwrite_presmodule->endcell();
 381         $kiriwrite_presmodule->addcell("tablecell2");
 382         $kiriwrite_presmodule->addinputbox("databasecategories", { Size => 64, MaxLength => 512 });
 383         $kiriwrite_presmodule->endcell();
 384         $kiriwrite_presmodule->endrow();
 385
 386         $kiriwrite_presmodule->startrow();
 387         $kiriwrite_presmodule->addcell("tablecell1");
 388         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasenotes});
 389         $kiriwrite_presmodule->endcell();
 390         $kiriwrite_presmodule->addcell("tablecell2");
 391         $kiriwrite_presmodule->addtextbox("databasenotes", { Columns => $kiriwrite_config{"display_textareacols"}, Rows => $kiriwrite_config{"display_textarearows"}, WordWrap => 0 });
 392         $kiriwrite_presmodule->endcell();
 393         $kiriwrite_presmodule->endrow();
 394
 395         $kiriwrite_presmodule->startrow();
 396         $kiriwrite_presmodule->addcell("tablecell1");
 397         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasefilename});
 398         $kiriwrite_presmodule->endcell();
 399         $kiriwrite_presmodule->addcell("tablecell2");
 400         $kiriwrite_presmodule->addinputbox("databasefilename", { Size => 32, MaxLength => 32 });
 401         $kiriwrite_presmodule->startlist();
 402         $kiriwrite_presmodule->additem($kiriwrite_lang->{database}->{adddatabaseautogenerate});
 403         $kiriwrite_presmodule->additem($kiriwrite_lang->{database}->{adddatabasenoextensions});
 404         $kiriwrite_presmodule->additem($kiriwrite_lang->{database}->{adddatabasecharacterlength});
 405         $kiriwrite_presmodule->additem($kiriwrite_lang->{database}->{adddatabasecharacters});
 406         $kiriwrite_presmodule->endlist();
 407         $kiriwrite_presmodule->endcell();
 408         $kiriwrite_presmodule->endrow();
 409
 410         $kiriwrite_presmodule->endtable();
 411         $kiriwrite_presmodule->startbox();
 412         $kiriwrite_presmodule->addlinebreak();
 413         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{database}->{adddatabasebutton});
 414         $kiriwrite_presmodule->addtext("|");
 415         $kiriwrite_presmodule->addreset($kiriwrite_lang->{database}->{clearvaluesbutton});
 416         $kiriwrite_presmodule->addtext("| ");
 417         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{databaselistreturnlink} });
 418         $kiriwrite_presmodule->endbox();
 419         $kiriwrite_presmodule->endform();
 420
 421         # Exit the subroutine taking the data in the pagadata variable with it.
 422
 423         return $kiriwrite_presmodule->grab();
 424
 425 }
 426
 427 sub kiriwrite_database_edit{
 428 #################################################################################
 429 # kiriwrite_database_edit: Edits an database.                                   #
 430 #                                                                               #
 431 # Usage:                                                                        #
 432 #                                                                               #
 433 # kiriwrite_database_edit(filename, newfilename, newname, newdescription,       #
 434 #                               notes, categories, [confirm]);                  #
 435 #                                                                               #
 436 # filename              Specifies the filename of the database.                 #
 437 # newfilename           Specifies the new filename of the database.             #
 438 # newname               Specifies the new name of the database.                 #
 439 # newdescription        Specifies the new description of the database.          #
 440 # notes                 Specifies the new notes of the database.                #
 441 # categories            Specifies the new categories of the database.           #
 442 # confirm               Confirms the action to edit a database.                 #
 443 #################################################################################
 444
 445         # First, get all the variables passed to the subroutine.
 446
 447         my ($database_shortname, $database_newfilename, $database_newname, $database_newdescription, $database_notes, $database_categories, $database_confirm) = @_;
 448
 449         # Check if the database confirm value is blank and if it is
 450         # set the confirm value to 0.
 451
 452         if (!$database_confirm){
 453
 454                 $database_confirm = 0;
 455
 456         }
 457
 458         # Check if the database filename given is valid and return an error
 459         # if it isn't.
 460
 461         kiriwrite_variablecheck($database_shortname, "filename", "", 0);
 462
 463         # Check if the confirm variable has a value in it, if it has, check again to make sure it really is the correct value (Perl moans
 464         # if $database_confirm was used directly).
 465
 466         if ($database_confirm eq 1){
 467
 468                 # Check if the new data passes the validation tests below. First, check the length of the variables.
 469
 470                 my $database_name_check_utf8            = kiriwrite_variablecheck($database_newname, "utf8", 0, 0);
 471                 my $database_description_check_utf8     = kiriwrite_variablecheck($database_newdescription, "utf8", 0, 0);
 472                 my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
 473                 my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
 474
 475                 # Convert the UTF8 strings to make sure their length is accurate.
 476
 477                 $database_newname               = kiriwrite_utf8convert($database_newname);
 478                 $database_newdescription        = kiriwrite_utf8convert($database_newdescription);
 479                 $database_notes                 = kiriwrite_utf8convert($database_notes);
 480                 $database_categories            = kiriwrite_utf8convert($database_categories);
 481
 482                 # Preform the following tests.
 483
 484                 my $database_filename_check_length      = kiriwrite_variablecheck($database_newfilename, "maxlength", 32, 1);
 485                 my $database_filename_letnum            = kiriwrite_variablecheck($database_newfilename, "filename", 0, 0);
 486                 my $database_name_check_length          = kiriwrite_variablecheck($database_newname, "maxlength", 256, 1);
 487                 my $database_description_check_length   = kiriwrite_variablecheck($database_newdescription, "maxlength", 512, 1);
 488                 my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
 489                 my $database_name_check_blank           = kiriwrite_variablecheck($database_newname, "blank", 0, 1);
 490
 491                 # Check if the data is valid and return a specific error if it doesn't.
 492
 493                 if ($database_name_check_length eq 1){
 494
 495                         # The length of the database name is too long, so return an error.
 496                         kiriwrite_error("databasenametoolong");
 497
 498                 }
 499
 500                 if ($database_description_check_length eq 1){
 501
 502                         # The database description length is too long, so return an error.
 503                         kiriwrite_error("databasedescriptiontoolong");
 504
 505                 }
 506
 507                 if ($database_name_check_blank eq 1){
 508
 509                         # The database name is blank, so return an error.
 510                         kiriwrite_error("databasenameblank");
 511
 512                 }
 513
 514                 if ($database_filename_check_length eq 1){
 515
 516                         # The database filename is too long, so return an error.
 517                         kiriwrite_error("databasefilenametoolong");
 518
 519                 }
 520
 521                 if ($database_categories_check_length eq 1){
 522
 523                         # The database categories is too long, so return an error.
 524                         kiriwrite_error("databasecategoriestoolong");
 525
 526                 }
 527
 528                 # Connect to the database server.
 529
 530                 $kiriwrite_dbmodule->connect();
 531
 532                 # Check if any errors occured while connecting to the database server.
 533
 534                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 535
 536                         # A database connection error has occured so return
 537                         # an error.
 538
 539                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 540
 541                 }
 542
 543                 # Get the database.
 544
 545                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database_shortname });
 546
 547                 # Check if any errors had occured while selecting the database.
 548
 549                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 550
 551                         # The database does not exist, so return an error.
 552
 553                         kiriwrite_error("databasemissingfile");
 554
 555                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 556
 557                         # The database has invalid permissions set, so return
 558                         # an error.
 559
 560                         kiriwrite_error("databaseinvalidpermissions");
 561
 562                 }
 563
 564                 # FIX THIS!! >O
 565
 566                 $kiriwrite_dbmodule->editdatabase({ DatabaseNewFilename => $database_newfilename, DatabaseName => $database_newname , DatabaseDescription => $database_newdescription , DatabaseNotes => $database_notes, DatabaseCategories => $database_categories });
 567
 568                 # Check if any errors had occured while using the database.
 569
 570                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 571
 572                         # The database does not exist, so return an error.
 573
 574                         kiriwrite_error("databasemissingfile");
 575
 576                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 577
 578                         # The database has invalid permissions set, so return
 579                         # an error.
 580
 581                         kiriwrite_error("databaseinvalidpermissions");
 582
 583                 } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
 584
 585                         # The database directory has invalid permissions set, so
 586                         # return an error.
 587
 588                         kiriwrite_error("datadirectoryinvalidpermissions");
 589
 590                 } elsif ($kiriwrite_dbmodule->geterror eq "DatabaseExists"){
 591
 592                         # A database already exists with the new filename, so
 593                         # return an error.
 594
 595                         kiriwrite_error("databasealreadyexists");
 596
 597                 } elsif ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 598
 599                         # A database error has occured so return an error with
 600                         # the extended error information.
 601
 602                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 603
 604                 }
 605
 606                 # Disconnect from the server.
 607
 608                 $kiriwrite_dbmodule->disconnect();
 609
 610                 # Write out a message saying that the database has been updated.
 611
 612                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{editeddatabase}, { Style => "pageheader" } );
 613                 $kiriwrite_presmodule->addlinebreak();
 614                 $kiriwrite_presmodule->addlinebreak();
 615                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{database}->{databaseupdated}, $database_newname));
 616                 $kiriwrite_presmodule->addlinebreak();
 617                 $kiriwrite_presmodule->addlinebreak();
 618                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{databaselistreturnlink} });
 619
 620                 return $kiriwrite_presmodule->grab();
 621
 622         } else {
 623
 624                 my (%database_info);
 625
 626                 # Check if the database filename given is valid and return an error
 627                 # if it isn't.
 628
 629                 # Connect to the database server.
 630
 631                 $kiriwrite_dbmodule->connect();
 632
 633                 # Check if any errors occured while connecting to the database server.
 634
 635                 if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 636
 637                         # A database connection error has occured so return
 638                         # an error.
 639
 640                         kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 641
 642                 }
 643
 644                 # Select the database.
 645
 646                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database_shortname });
 647
 648                 # Check if any errors had occured while setting the database.
 649
 650                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 651
 652                         # The database does not exist, so return an error.
 653
 654                         kiriwrite_error("databasemissingfile");
 655
 656                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet"){
 657
 658                         # The database has invalid permissions set, so return
 659                         # an error.
 660
 661                         kiriwrite_error("databaseinvalidpermissions");
 662
 663                 }
 664
 665                 # Get the database information.
 666
 667                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
 668
 669                 # Check if any errors had occured while getting the database
 670                 # information.
 671
 672                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 673
 674                         # A database error has occured so return an error and
 675                         # also the extended error information.
 676
 677                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 678
 679                 }
 680
 681                 # Get the values needed from the kiriwrite_database_info table.
 682
 683                 my $database_oldname            = $database_info{"DatabaseName"};
 684                 my $database_olddescription     = $database_info{"Description"};
 685                 my $database_notes              = $database_info{"Notes"};
 686                 my $database_categories         = $database_info{"Categories"};
 687
 688                 # Disconnect from the database server.
 689
 690                 $kiriwrite_dbmodule->disconnect();
 691
 692                 # Print out the form for editing a database's settings.
 693
 694                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{database}->{editdatabase}, $database_oldname), { Style => "pageheader" });
 695                 $kiriwrite_presmodule->addlinebreak();
 696                 $kiriwrite_presmodule->addlinebreak();
 697                 $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
 698                 $kiriwrite_presmodule->startbox();
 699                 $kiriwrite_presmodule->addhiddendata("mode", "db");
 700                 $kiriwrite_presmodule->addhiddendata("action", "edit");
 701                 $kiriwrite_presmodule->addhiddendata("database", $database_shortname);
 702                 $kiriwrite_presmodule->addhiddendata("confirm", "1");
 703                 $kiriwrite_presmodule->endbox();
 704
 705                 $kiriwrite_presmodule->starttable("", { CellPadding => 5, CellSpacing => 0 });
 706                 $kiriwrite_presmodule->startheader();
 707                 $kiriwrite_presmodule->addheader("Setting", { Style => "tablecellheader" });
 708                 $kiriwrite_presmodule->addheader("Value", { Style => "tablecellheader" });
 709                 $kiriwrite_presmodule->endheader();
 710
 711                 $kiriwrite_presmodule->startrow();
 712                 $kiriwrite_presmodule->addcell("tablecell1");
 713                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasename});
 714                 $kiriwrite_presmodule->endcell();
 715                 $kiriwrite_presmodule->addcell("tablecell2");
 716                 $kiriwrite_presmodule->addinputbox("databasename", { Size => 64, MaxLength => 256, Value => $database_oldname } );
 717                 $kiriwrite_presmodule->endcell();
 718                 $kiriwrite_presmodule->endrow();
 719
 720                 $kiriwrite_presmodule->startrow();
 721                 $kiriwrite_presmodule->addcell("tablecell1");
 722                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasedescription});
 723                 $kiriwrite_presmodule->endcell();
 724                 $kiriwrite_presmodule->addcell("tablecell2");
 725                 $kiriwrite_presmodule->addinputbox("databasedescription", { Size => 64, MaxLength => 512, Value => $database_olddescription } );
 726                 $kiriwrite_presmodule->endcell();
 727                 $kiriwrite_presmodule->endrow();
 728
 729                 $kiriwrite_presmodule->startrow();
 730                 $kiriwrite_presmodule->addcell("tablecell1");
 731                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasecategories});
 732                 $kiriwrite_presmodule->endcell();
 733                 $kiriwrite_presmodule->addcell("tablecell2");
 734                 $kiriwrite_presmodule->addinputbox("databasecategories", { Size => 64, MaxLength => 512, Value => $database_categories } );
 735                 $kiriwrite_presmodule->endcell();
 736                 $kiriwrite_presmodule->endrow();
 737
 738                 $kiriwrite_presmodule->startrow();
 739                 $kiriwrite_presmodule->addcell("tablecell1");
 740                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasenotes});
 741                 $kiriwrite_presmodule->endcell();
 742                 $kiriwrite_presmodule->addcell("tablecell2");
 743                 $kiriwrite_presmodule->addtextbox("databasenotes", { Columns => $kiriwrite_config{"display_textareacols"}, Rows => $kiriwrite_config{"display_textarearows"}, Value => $database_notes } );
 744                 $kiriwrite_presmodule->endcell();
 745                 $kiriwrite_presmodule->endrow();
 746
 747                 $kiriwrite_presmodule->startrow();
 748                 $kiriwrite_presmodule->addcell("tablecell1");
 749                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databasefilename});
 750                 $kiriwrite_presmodule->endcell();
 751                 $kiriwrite_presmodule->addcell("tablecell2");
 752                 $kiriwrite_presmodule->addinputbox("databasefilename", { Size => 32, MaxLength => 32, Value => $database_shortname } );
 753                 $kiriwrite_presmodule->endcell();
 754                 $kiriwrite_presmodule->endrow();
 755
 756                 $kiriwrite_presmodule->endtable();
 757
 758                 $kiriwrite_presmodule->startbox();
 759                 $kiriwrite_presmodule->addlinebreak();
 760                 $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{database}->{editdatabasebutton});
 761                 $kiriwrite_presmodule->addtext(" | ");
 762                 $kiriwrite_presmodule->addreset($kiriwrite_lang->{common}->{restorecurrent});
 763                 $kiriwrite_presmodule->addtext(" | ");
 764                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{databaselistreturnlink} });
 765                 $kiriwrite_presmodule->endbox();
 766                 $kiriwrite_presmodule->endform();
 767
 768                 return $kiriwrite_presmodule->grab();
 769
 770         }
 771
 772         # The interpreter should not be here. So return an error saying invalid variable.
 773
 774         kiriwrite_error("invalidvariable");
 775
 776 }
 777
 778 sub kiriwrite_database_delete{
 779 #################################################################################
 780 # kiriwrite_database_delete: Deletes an database.                               #
 781 #                                                                               #
 782 # Usage:                                                                        #
 783 #                                                                               #
 784 # kiriwrite_database_delete(filename, [confirm]);                               #
 785 #                                                                               #
 786 # filename      Specifies the filename for the database to be deleted.          #
 787 # confirm       Confirms the action to delete a database.                       #
 788 #################################################################################
 789
 790         my ($database_filename, $database_confirm) = @_;
 791
 792         # Check if the confirm value is blank and if it is then set the
 793         # confirm value to 0.
 794
 795         if (!$database_confirm){
 796
 797                 $database_confirm = 0;
 798
 799         }
 800
 801         # Connect to the database server.
 802
 803         $kiriwrite_dbmodule->connect();
 804
 805         # Check if any errors occured while connecting to the database server.
 806
 807         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 808
 809                 # A database connection error has occured so return
 810                 # an error.
 811
 812                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 813
 814         }
 815
 816         # Check if the database filename given is valid and return an error
 817         # if it isn't.
 818
 819         kiriwrite_variablecheck($database_filename, "filename", "", 0);
 820
 821         # Check if the request to delete a database has been confirmed. If it has,
 822         # then delete the database itself.
 823
 824         if ($database_confirm eq 1){
 825                 # There is a value in the confirm variable of the HTTP query.
 826
 827                 # Select the database to delete and get the database name.
 828
 829                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $database_filename });
 830
 831                 # Check if any error occured while selecting the database.
 832
 833                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 834
 835                         # The database does not exist so return an error.
 836
 837                         kiriwrite_error("databasemissingfile");
 838
 839                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet") {
 840
 841                         # The database has invalid permissions set so return
 842                         # an error.
 843
 844                         kiriwrite_error("databaseinvalidpermissions");
 845
 846                 }
 847
 848                 my %database_info       = $kiriwrite_dbmodule->getdatabaseinfo();
 849
 850                 # Check if any errors have occured while getting the database
 851                 # name.
 852
 853                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 854
 855                         # A database error has occured so return an error with
 856                         # the extended error information.
 857
 858                         kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 859
 860                 }
 861
 862                 my $database_name = $database_info{"DatabaseName"};
 863
 864                 # Delete the selected database.
 865
 866                 $kiriwrite_dbmodule->deletedatabase({ DatabaseName => $database_filename });
 867
 868                 # Check if any error occured while deleting the database.
 869
 870                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 871
 872                         # The database does not exist so return an error.
 873
 874                         kiriwrite_error("databasemissingfile");
 875
 876                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet") {
 877
 878                         # The database has invalid permissions set so return
 879                         # an error.
 880
 881                         kiriwrite_error("databaseinvalidpermissions");
 882
 883                 }
 884
 885                 # Disconnect from the database server.
 886
 887                 $kiriwrite_dbmodule->disconnect();
 888
 889                 # Write a message saying that the database has been deleted.
 890
 891                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{deleteddatabase}, { Style => "pageheader" });
 892                 $kiriwrite_presmodule->addlinebreak();
 893                 $kiriwrite_presmodule->addlinebreak();
 894                 $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{database}->{deleteddatabasemessage}, $database_name));
 895                 $kiriwrite_presmodule->addlinebreak();
 896                 $kiriwrite_presmodule->addlinebreak();
 897                 $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{databaselistreturnlink} });
 898
 899                 return $kiriwrite_presmodule->grab();
 900
 901         }
 902
 903         # The action has not been confirmed, so write out a form asking the
 904         # user to confirm.
 905
 906         # Get the database name.
 907
 908         $kiriwrite_dbmodule->selectdb({ DatabaseName => $database_filename });
 909
 910         # Check if any error occured while selecting the database.
 911
 912         if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
 913
 914                 # The database does not exist so return an error.
 915
 916                 kiriwrite_error("databasemissingfile");
 917
 918         } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet") {
 919
 920                 # The database has invalid permissions set so return
 921                 # an error.
 922
 923                 kiriwrite_error("databaseinvalidpermissions");
 924
 925
 926         }
 927
 928         # Check if any errors have occured.
 929
 930         my %database_info       = $kiriwrite_dbmodule->getdatabaseinfo();
 931
 932         if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
 933
 934                 # A database error has occured so return an error with
 935                 # the extended error information.
 936
 937                 kiriwrite_error("databaseerror", $kiriwrite_dbmodule->geterror(1));
 938
 939         }
 940
 941         my $database_name = $database_info{"DatabaseName"};
 942
 943         # Disconnect from the database server.
 944
 945         $kiriwrite_dbmodule->disconnect();
 946
 947         # Write out the form to ask the user to confirm the deletion of the
 948         # selected database.
 949
 950         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{deletedatabase}, { Style => "pageheader" });
 951         $kiriwrite_presmodule->startform($kiriwrite_env{"script_filename"}, "POST");
 952         $kiriwrite_presmodule->startbox();
 953         $kiriwrite_presmodule->addhiddendata("mode", "db");
 954         $kiriwrite_presmodule->addhiddendata("action", "delete");
 955         $kiriwrite_presmodule->addhiddendata("database", $database_filename);
 956         $kiriwrite_presmodule->addhiddendata("confirm", "1");
 957         $kiriwrite_presmodule->addlinebreak();
 958         $kiriwrite_presmodule->addtext(kiriwrite_language($kiriwrite_lang->{database}->{deletedatabasemessage}, $database_name));
 959         $kiriwrite_presmodule->addlinebreak();
 960         $kiriwrite_presmodule->addlinebreak();
 961         $kiriwrite_presmodule->addsubmit($kiriwrite_lang->{database}->{deletedatabasebutton});
 962         $kiriwrite_presmodule->addtext(" | ");
 963         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=db", { Text => $kiriwrite_lang->{database}->{deletedatabasereturn} });
 964         $kiriwrite_presmodule->endbox();
 965         $kiriwrite_presmodule->endform();
 966
 967         return $kiriwrite_presmodule->grab();
 968
 969 }
 970
 971 sub kiriwrite_database_list{
 972 #################################################################################
 973 # kiriwrite_database_list: Lists the databases available.                       #
 974 #                                                                               #
 975 # Usage:                                                                        #
 976 #                                                                               #
 977 # kiriwrite_database_list();                                                    #
 978 #################################################################################
 979
 980         # Connect to the database server.
 981
 982         $kiriwrite_dbmodule->connect();
 983
 984         # Check if any errors occured while connecting to the database server.
 985
 986         if ($kiriwrite_dbmodule->geterror eq "DatabaseConnectionError"){
 987
 988                 # A database connection error has occured so return
 989                 # an error.
 990
 991                 kiriwrite_error("databaseconnectionerror", $kiriwrite_dbmodule->geterror(1));
 992
 993         }
 994
 995         # Get the list of available databases and process any errors that
 996         # might have occured.
 997
 998         my @database_list = $kiriwrite_dbmodule->getdblist();
 999
1000         if ($kiriwrite_dbmodule->geterror eq "DataDirMissing"){
1001
1002                 # The database directory is missing so return an error.
1003
1004                 kiriwrite_error("datadirectorymissing");
1005
1006         } elsif ($kiriwrite_dbmodule->geterror eq "DataDirInvalidPermissions"){
1007
1008                 # The database directory has invalid permissions set so return
1009                 # an error.
1010
1011                 kiriwrite_error("datadirectoryinvalidpermissions");
1012
1013         }
1014
1015         # Declare the following variables that are going to be used before using
1016         # the foreach function.
1017
1018         my ($database_info, %database_info);
1019         my @error_list;
1020         my @permissions_list;
1021         my $database_count = 0;
1022         my $database_filename = "";
1023         my $database_filename_friendly = "";
1024         my $database_filename_length = 0;
1025         my $database_name = "";
1026         my $database_description = "";
1027         my $database_permissions = "";
1028         my $nodescription = 0;
1029         my $noname = 0;
1030         my $data_file = "";
1031         my $table_style = 0;
1032         my $table_style_name = "";
1033
1034         # Begin creating the table for the list of databases.
1035
1036         $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaselist}, { Style => "pageheader" });
1037         $kiriwrite_presmodule->addlinebreak();
1038         $kiriwrite_presmodule->addlinebreak();
1039         $kiriwrite_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
1040         $kiriwrite_presmodule->startheader();
1041         $kiriwrite_presmodule->addheader($kiriwrite_lang->{database}->{databasename}, { Style => "tablecellheader" });
1042         $kiriwrite_presmodule->addheader($kiriwrite_lang->{database}->{databasedescription}, { Style => "tablecellheader" });
1043         $kiriwrite_presmodule->addheader($kiriwrite_lang->{database}->{databaseoptions}, { Style => "tablecellheader" });
1044         $kiriwrite_presmodule->endheader();
1045
1046         foreach $data_file (@database_list){
1047
1048                 # Select the database.
1049
1050                 $kiriwrite_dbmodule->selectdb({ DatabaseName => $data_file });
1051
1052                 # Check if any error occured while selecting the database.
1053
1054                 if ($kiriwrite_dbmodule->geterror eq "DoesNotExist"){
1055
1056                         # The database does not exist, so process the next
1057                         # database.
1058
1059                         next;
1060
1061                 } elsif ($kiriwrite_dbmodule->geterror eq "InvalidPermissionsSet") {
1062
1063                         # The database has invalid permissions settings, so
1064                         # add the database to the list of databases with
1065                         # invalid permissions set and process the next
1066                         # database.
1067
1068                         push(@permissions_list, $data_file);
1069                         next;
1070
1071                 }
1072
1073                 # Get information about the database.
1074
1075                 %database_info = $kiriwrite_dbmodule->getdatabaseinfo();
1076
1077                 # Check if any error occured while getting information from the
1078                 # database.
1079
1080                 if ($kiriwrite_dbmodule->geterror eq "DatabaseError"){
1081
1082                         # A database error has occured, add the database and specific
1083                         # error message to the list of databases with errors and
1084                         # process the next database.
1085
1086                         push(@error_list, $data_file . ": " . $kiriwrite_dbmodule->geterror(1));
1087                         next;
1088
1089                 }
1090
1091                 $database_name          = $database_info{"DatabaseName"};
1092                 $database_description   = $database_info{"Description"};
1093
1094                 # Check the style to be used with.
1095
1096                 if ($table_style eq 0){
1097
1098                         # Use the first style and set the style value
1099                         # to use the next style, the next time the
1100                         # if statement is checked.
1101
1102                         $table_style_name = "tablecell1";
1103                         $table_style = 1;
1104                 } else {
1105
1106                         # Use the second style and set the style
1107                         # value to use the first style, the next
1108                         # time if statement is checked.
1109
1110                         $table_style_name = "tablecell2";
1111                         $table_style = 0;
1112                 }
1113
1114                 # Create a friendly name for the database.
1115
1116                 $database_filename_friendly = $data_file;
1117
1118                 # Append the database information to the table.
1119
1120                 $kiriwrite_presmodule->startrow();
1121                 $kiriwrite_presmodule->addcell($table_style_name);
1122
1123                 if (!$database_name){
1124                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{noname});
1125                 } else {
1126                         $kiriwrite_presmodule->addlink($kiriwrite_env{"script_filename"} . "?mode=page&action=view&database=" . $database_filename_friendly, { Text => $database_name });
1127                 }
1128
1129                 $kiriwrite_presmodule->endcell();
1130                 $kiriwrite_presmodule->addcell($table_style_name);
1131
1132                 if (!$database_description){
1133                         $kiriwrite_presmodule->additalictext($kiriwrite_lang->{blank}->{nodescription});
1134                 } else {
1135                         $kiriwrite_presmodule->addtext($database_description);
1136                 }
1137
1138                 $kiriwrite_presmodule->endcell();
1139                 $kiriwrite_presmodule->addcell($table_style_name);
1140                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=db&action=edit&database=" . $database_filename_friendly, { Text => $kiriwrite_lang->{options}->{edit} });
1141                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=compile&action=compile&type=single&database=" . $database_filename_friendly, { Text => $kiriwrite_lang->{options}->{compile} });
1142                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=db&action=delete&database=" . $database_filename_friendly, { Text => $kiriwrite_lang->{options}->{delete} });
1143                 $kiriwrite_presmodule->endrow();
1144
1145                 $database_count++;
1146                 $nodescription = 0;
1147                 $noname = 0;
1148
1149         }
1150
1151         $kiriwrite_presmodule->endtable();
1152
1153         # Disconnect from the database server.
1154
1155         $kiriwrite_dbmodule->disconnect();
1156
1157         # Check if there are no valid databases are if there is no
1158         # valid databases then write a message saying that no
1159         # valid databases are available.
1160
1161         if ($database_count eq 0){
1162
1163                 $kiriwrite_presmodule->clear();
1164                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaselist}, { Style => "pageheader" });
1165                 $kiriwrite_presmodule->addlinebreak();
1166                 $kiriwrite_presmodule->addlinebreak();
1167                 $kiriwrite_presmodule->startbox("errorbox");
1168                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{nodatabasesavailable});
1169                 $kiriwrite_presmodule->endbox();
1170
1171         }
1172
1173         # Check if any databases with problems have appeared and if they
1174         # have, print out a message saying which databases have problems.
1175
1176         if (@permissions_list){
1177
1178                 $kiriwrite_presmodule->addlinebreak();
1179                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseinvalidpermissions}, { Style => "smallpageheader" });
1180                 $kiriwrite_presmodule->addlinebreak();
1181                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseinvalidpermissionstext});
1182                 $kiriwrite_presmodule->addlinebreak();
1183
1184                 foreach $data_file (@permissions_list){
1185                         $kiriwrite_presmodule->addlinebreak();
1186                         $kiriwrite_presmodule->addtext($data_file);
1187                 }
1188
1189                 $kiriwrite_presmodule->addlinebreak();
1190
1191         }
1192
1193         if (@error_list){
1194
1195                 $kiriwrite_presmodule->addlinebreak();
1196                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseerrors}, { Style => "smallpageheader" });
1197                 $kiriwrite_presmodule->addlinebreak();
1198                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{database}->{databaseerrorstext});
1199                 $kiriwrite_presmodule->addlinebreak();
1200
1201                 foreach $data_file (@error_list){
1202                         $kiriwrite_presmodule->addlinebreak();
1203                         $kiriwrite_presmodule->addtext($data_file);
1204                 }
1205
1206                 $kiriwrite_presmodule->addlinebreak();
1207
1208         }
1209
1210         return $kiriwrite_presmodule->grab();   # Return to the main part of the script with the processed information.
1211
1212 }
1213
1214 1;