cgi-files/Modules/System/Database.pm

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