cgi-files/Modules/Database/SQLite.pm

   1 #################################################################################
   2 # Kiriwrite Database Module - SQLite Database Module (SQLite.pm)                #
   3 # Database module for mainipulating SQLite databases in the database directory. #
   4 #                                                                               #
   5 # Copyright (C) 2007 Steve Brokenshire <sbrokenshire@xestia.co.uk>              #
   6 #                                                                               #
   7 # This module is licensed under the same license as Kiriwrite which is the GPL. #
   8 #                                                                               #
   9 # This program is free software; you can redistribute it and/or modify it under #
  10 # the terms of the GNU General Public License as published by the Free          #
  11 # Software Foundation; as version 2 of the License.                             #
  12 #                                                                               #
  13 # This program is distributed in the hope that it will be useful, but WITHOUT   #
  14 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS #
  15 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.#
  16 #                                                                               #
  17 # You should have received a copy of the GNU General Public License along with  #
  18 # this program; if not, write to the Free Software Foundation, Inc., 51         #
  19 # Franklin St, Fifth Floor, Boston, MA 02110-1301 USA                           #
  20 #################################################################################
  21
  22 # Define the package (perl module) name.
  23
  24 package Kiriwrite::Database::SQLite;
  25
  26 # Enable strict and use warnings.
  27
  28 use strict;
  29 use warnings;
  30
  31 # Load the following Perl modules.
  32
  33 use DBI qw(:sql_types);
  34
  35 # Set the following values.
  36
  37 our $VERSION    = "0.1.0";
  38 my ($options, %options);
  39 my $database_handle;
  40 my $string_handle;
  41 my $error = "";
  42 my $errorext = "";
  43 my $database_filename;
  44 my $second_database_filename;
  45 my $second_database_handle;
  46 my $second_string_handle;
  47 my $templatedb_loaded = 0;
  48 my $templatedb_exists = 1;
  49 my $template_string_handle;
  50 my $template_database_handle;
  51 my $filterdb_loaded = 0;
  52 my $filterdb_exists = 1;
  53 my $filterdb_string_handle;
  54 my $filterdb_database_handle;
  55
  56
  57 #################################################################################
  58 # Generic Subroutines.                                                          #
  59 #################################################################################
  60
  61 sub new{
  62 #################################################################################
  63 # new: Create an instance of Kiriwrite::Database::SQLite                        #
  64 #                                                                               #
  65 # Usage:                                                                        #
  66 #                                                                               #
  67 # $dbmodule = Kiriwrite::Database::SQLite->new();                               #
  68 #################################################################################
  69
  70         # Get the perl module name.
  71
  72         my $class = shift;
  73         my $self = {};
  74
  75         return bless($self, $class);
  76
  77 }
  78
  79 sub loadsettings{
  80 #################################################################################
  81 # loadsettings: Loads settings into the SQLite database module                  #
  82 #                                                                               #
  83 # Usage:                                                                        #
  84 #                                                                               #
  85 # $dbmodule->loadsettings(Directory, options);                                  #
  86 #                                                                               #
  87 # options       Specifies the following options (in any order).                 #
  88 #                                                                               #
  89 # Directory     Specifies the directory to use for getting databases.           #
  90 # DateTime      Specifies the date and time format to use.                      #
  91 # Server        Specifies the server to use.                                    #
  92 # Database      Specifies the database to use.                                  #
  93 # Username      Specifies the username to use.                                  #
  94 # Password      Specifies the password to use.                                  #
  95 # HashType      Specifies the password hash type to use.                        #
  96 # Port          Specifies the server port to use.                               #
  97 # Protocol      Specifies the protocol to use.                                  #
  98 # TablePrefix   Specifies the table prefix to use.                              #
  99 #################################################################################
 100
 101         # Get the data passed to the subroutine.
 102
 103         my $class = shift;
 104         my ($passedoptions)     = @_;
 105
 106         # Add the directory setting to the list of options (as it's the only
 107         # one needed for this database module).
 108
 109         %options = (
 110                 "Directory"     => $passedoptions->{"Directory"},
 111                 "DateTime"      => $passedoptions->{"DateTime"},
 112         );
 113
 114 }
 115
 116 sub convert{
 117 #################################################################################
 118 # convert: Converts data into SQL formatted data.                               #
 119 #                                                                               #
 120 # Usage:                                                                        #
 121 #                                                                               #
 122 # $dbmodule->convert(data);                                                     #
 123 #                                                                               #
 124 # data          Specifies the data to convert.                                  #
 125 #################################################################################
 126
 127         # Get the data passed to the subroutine.
 128
 129         my $class       = shift;
 130         my $data        = shift;
 131
 132         if (!$data){
 133                 $data = "";
 134         }
 135
 136         $data =~ s/'/''/g;
 137         $data =~ s/\b//g;
 138
 139         return $data;
 140
 141 }
 142
 143 sub dateconvert{
 144 #################################################################################
 145 # dateconvert: Converts a SQL date into a proper date.                          #
 146 #                                                                               #
 147 # Usage:                                                                        #
 148 #                                                                               #
 149 # $dbmodule->dateconvert(date);                                                 #
 150 #                                                                               #
 151 # date          Specifies the date to convert.                                  #
 152 #################################################################################
 153
 154         # Get the date passed to the subroutine.
 155
 156         my $class       = shift;
 157         my $data        = shift;
 158
 159         # Convert the date given into the proper date.
 160
 161         # Create the following varialbes to be used later.
 162
 163         my $date;
 164         my $time;
 165         my $day;
 166         my $day_full;
 167         my $month;
 168         my $month_check;
 169         my $month_full;
 170         my $year;
 171         my $year_short;
 172         my $hour;
 173         my $hour_full;
 174         my $minute;
 175         my $minute_full;
 176         my $second;
 177         my $second_full;
 178         my $seek = 0;
 179         my $timelength;
 180         my $datelength;
 181         my $daylength;
 182         my $secondlength;
 183         my $startchar = 0;
 184         my $char;
 185         my $length;
 186         my $count = 0;
 187
 188         # Split the date and time.
 189
 190         $length = length($data);
 191
 192         if ($length > 0){
 193
 194                 do {
 195
 196                         # Get the character and check if it is a space.
 197
 198                         $char = substr($data, $seek, 1);
 199
 200                         if ($char eq ' '){
 201
 202                                 # The character is a space, so get the date and time.
 203
 204                                 $date           = substr($data, 0, $seek);
 205                                 $timelength     = $length - $seek - 1;
 206                                 $time           = substr($data, $seek + 1, $timelength);
 207
 208                         }
 209
 210                         $seek++;
 211
 212                 } until ($seek eq $length);
 213
 214                 # Get the year, month and date.
 215
 216                 $length = length($date);
 217                 $seek = 0;
 218
 219                 do {
 220
 221                         # Get the character and check if it is a dash.
 222
 223                         $char = substr($date, $seek, 1);
 224
 225                         if ($char eq '-'){
 226
 227                                 # The character is a dash, so get the year, month or day.
 228
 229                                 $datelength = $seek - $startchar;
 230
 231                                 if ($count eq 0){
 232
 233                                         # Get the year from the date.
 234
 235                                         $year           = substr($date, 0, $datelength) + 1900;
 236                                         $startchar      = $seek;
 237                                         $count = 1;
 238
 239                                         # Get the last two characters to get the short year
 240                                         # version.
 241
 242                                         $year_short     = substr($year, 2, 2);
 243
 244                                 } elsif ($count eq 1){
 245
 246                                         # Get the month and day from the date.
 247
 248                                         $month  = substr($date, $startchar + 1, $datelength - 1) + 1;
 249
 250                                         # Check if the month is less then 10, if it is
 251                                         # add a zero to the value.
 252
 253                                         if ($month < 10){
 254
 255                                                 $month_full = '0' . $month;
 256
 257                                         } else {
 258
 259                                                 $month_full = $month;
 260
 261                                         }
 262
 263                                         $startchar      = $seek;
 264                                         $count = 2;
 265
 266                                         $daylength      = $length - $seek + 1;
 267                                         $day            = substr($date, $startchar + 1, $daylength);
 268
 269                                         # Check if the day is less than 10, if it is
 270                                         # add a zero to the value.
 271
 272                                         if ($day < 10){
 273
 274                                                 $day_full       = '0' . $day;
 275
 276                                         } else {
 277
 278                                                 $day_full       = $day;
 279
 280                                         }
 281
 282                                 }
 283
 284                         }
 285
 286                         $seek++;
 287
 288                 } until ($seek eq $length);
 289
 290                 # Get the length of the time value and reset certain
 291                 # values to 0.
 292
 293                 $length = length($time);
 294                 $seek = 0;
 295                 $count = 0;
 296                 $startchar = 0;
 297
 298                 do {
 299
 300                         # Get the character and check if it is a colon.
 301
 302                         $char = substr($time, $seek, 1);
 303
 304                         if ($char eq ':'){
 305
 306                                 # The character is a colon, so get the hour, minute and day.
 307
 308                                 $timelength = $seek - $startchar;
 309
 310                                 if ($count eq 0){
 311
 312                                         # Get the hour from the time.
 313
 314                                         $hour = substr($time, 0, $timelength);
 315                                         $count = 1;
 316                                         $startchar = $seek;
 317
 318                                         # If the hour is less than ten then add a
 319                                         # zero.
 320
 321                                         if ($hour < 10){
 322
 323                                                 $hour_full = '0' . $hour;
 324
 325                                         } else {
 326
 327                                                 $hour_full = $hour;
 328
 329                                         }
 330
 331                                 } elsif ($count eq 1){
 332
 333                                         # Get the minute and second from the time.
 334
 335                                         $minute = substr($time, $startchar + 1, $timelength - 1);
 336                                         $count = 2;
 337
 338                                         # If the minute is less than ten then add a
 339                                         # zero.
 340
 341                                         if ($minute < 10){
 342
 343                                                 $minute_full = '0' . $minute;
 344
 345                                         } else {
 346
 347                                                 $minute_full = $minute;
 348
 349                                         }
 350
 351                                         $startchar = $seek;
 352
 353                                         $secondlength = $length - $seek + 1;
 354                                         $second = substr($time, $startchar + 1, $secondlength);
 355
 356                                         # If the second is less than ten then add a
 357                                         # zero.
 358
 359                                         if ($second < 10){
 360
 361                                                 $second_full = '0' . $second;
 362
 363                                         } else {
 364
 365                                                 $second_full = $second;
 366
 367                                         }
 368
 369                                 }
 370
 371                         }
 372
 373                         $seek++;
 374
 375                 } until ($seek eq $length);
 376
 377                 # Get the setting for displaying the date and time.
 378
 379                 $data = $options{"DateTime"};
 380
 381                 # Process the setting for displaying the date and time
 382                 # using regular expressions
 383
 384                 $data =~ s/DD/$day_full/g;
 385                 $data =~ s/D/$day/g;
 386                 $data =~ s/MM/$month_full/g;
 387                 $data =~ s/M/$month/g;
 388                 $data =~ s/YY/$year/g;
 389                 $data =~ s/Y/$year_short/g;
 390
 391                 $data =~ s/hh/$hour_full/g;
 392                 $data =~ s/h/$hour/g;
 393                 $data =~ s/mm/$minute_full/g;
 394                 $data =~ s/m/$minute/g;
 395                 $data =~ s/ss/$second_full/g;
 396                 $data =~ s/s/$second/g;
 397
 398         }
 399
 400         return $data;
 401
 402 }
 403
 404 sub geterror{
 405 #################################################################################
 406 # geterror: Gets the error message (or extended error message).                 #
 407 #                                                                               #
 408 # Usage:                                                                        #
 409 #                                                                               #
 410 # $dbmodule->geterror(extended);                                                #
 411 #                                                                               #
 412 # Extended      Specifies if the extended error should be retrieved.            #
 413 #################################################################################
 414
 415         # Get the data passed to the subroutine.
 416
 417         my $class       = shift;
 418         my $extended    = shift;
 419
 420         if (!$extended){
 421                 $extended = 0;
 422         }
 423
 424         if (!$errorext){
 425                 $errorext = "";
 426         }
 427
 428         if (!$error){
 429                 $error = "";
 430         }
 431
 432         # Check to see if extended information should be returned.
 433
 434         if ($extended eq 1){
 435
 436                 # Extended information should be returned.
 437
 438                 return $errorext;
 439
 440         } else {
 441
 442                 # Basic information should be returned.
 443
 444                 return $error;
 445
 446         }
 447
 448 }
 449
 450 sub dbpermissions{
 451 #################################################################################
 452 # dbpermissions: Check if the permissions for the database are valid.           #
 453 #                                                                               #
 454 # Usage:                                                                        #
 455 #                                                                               #
 456 # $database->dbpermissions(dbname, read, write);                                #
 457 #                                                                               #
 458 # dbname        Specifies the database name to check.                           #
 459 # read          Check to see if the database can be read.                       #
 460 # write         Check to see if the database can be written.                    #
 461 #################################################################################
 462
 463         # Get the database name, read setting and write setting.
 464
 465         my ($class, $dbname, $readper, $writeper)       = @_;
 466
 467         # Check if the database can be read.
 468
 469         if ($readper){
 470
 471                 if (-r $options{"Directory"} . '/' . $dbname . ".db.sqlite"){
 472
 473                         # The database can be read.
 474
 475                 } else {
 476
 477                         # The database cannot be read, so return a value
 478                         # of 1.
 479
 480                         return 1;
 481
 482                 }
 483
 484         }
 485
 486         # Check if the database can be written.
 487
 488         if ($writeper){
 489
 490                 if (-w $options{"Directory"} . '/' . $dbname . ".db.sqlite"){
 491
 492                         # The database can be read.
 493
 494                 } else {
 495
 496                         # The database cannot be read, so return a value
 497                         # of 1.
 498
 499                         return 1;
 500
 501                 }
 502
 503         }
 504
 505         # No errors have occured while checking so return a value
 506         # of 0.
 507
 508         return 0;
 509
 510 }
 511
 512 sub dbexists{
 513 #################################################################################
 514 # dbexists: Check if the database exists.                                       #
 515 #                                                                               #
 516 # Usage:                                                                        #
 517 #                                                                               #
 518 # $dbmodule->dbexists(dbname);                                                  #
 519 #                                                                               #
 520 # dbname        Specifies the database name to check.                           #
 521 #################################################################################
 522
 523         # Get the value that was passed to the subroutine.
 524
 525         my $class       = shift;
 526         my ($filename)  = @_;
 527
 528         # Check if the filename exists, if it does, return a value of 1, else
 529         # return a value of 0, meaning that the file was not found.
 530
 531         if (-e $options{"Directory"} . '/' . $filename . ".db.sqlite"){
 532
 533                 # Specified file does exist so return a value of 0.
 534
 535                 return 0;
 536
 537         } else {
 538
 539                 # Specified file does not exist so return a value of 1.
 540
 541                 return 1;
 542
 543         }
 544
 545 }
 546
 547 #################################################################################
 548 # Database Subroutines.                                                         #
 549 #################################################################################
 550
 551 sub getdblist{
 552 #################################################################################
 553 # getdblist: Gets the list of available databases.                              #
 554 #                                                                               #
 555 # Usage:                                                                        #
 556 #                                                                               #
 557 # $dbmodule->getdblist();                                                       #
 558 #################################################################################
 559
 560         # Get the list of databases.
 561
 562         my @data_directory;
 563         my @data_directory_final;
 564         my $database;
 565         my $database_filename_length;
 566         my $database_filename_friendly;
 567
 568         # Check if the database directory has valid permission settings.
 569
 570         if (-e $options{"Directory"}){
 571
 572                 # The database directory does exist. So check if
 573                 # the permission settings are valid.
 574
 575                 if (-r $options{"Directory"}){
 576
 577                         # The permission settings for reading the directory
 578                         # are valid.
 579
 580                 } else {
 581
 582                         # The permission settings for reading the directory
 583                         # are invalid so return an error value.
 584
 585                         $error = "DataDirInvalidPermissions";
 586                         return;
 587
 588                 }
 589
 590         } else {
 591
 592                 # The database directory does not exist, so return an
 593                 # error value.
 594
 595                 $error = "DataDirMissing";
 596                 return;
 597
 598         }
 599
 600         opendir(DATADIR, $options{"Directory"});
 601         @data_directory = grep /m*\.db.sqlite$/, readdir(DATADIR);
 602         closedir(DATADIR);
 603
 604         # Process the list of databases.
 605
 606         foreach $database (@data_directory){
 607
 608                 $database =~ s/.db.sqlite$//og;
 609                 $database_filename_friendly = $database;
 610
 611                 #$database_filename_length = length($database);
 612                 #$database_filename_friendly = substr($database, 0, $database_filename_length - 10);
 613                 push(@data_directory_final, $database_filename_friendly);
 614
 615         }
 616
 617         # Return the list of databases.
 618
 619         return @data_directory_final;
 620
 621 }
 622
 623 sub getdatabaseinfo{
 624 #################################################################################
 625 # getdatabaseinfo: Get information about the database.                          #
 626 #                                                                               #
 627 # Usage:                                                                        #
 628 #                                                                               #
 629 # $dbmodule->getdatabaseinfo();                                                 #
 630 #################################################################################
 631
 632         # Get the database information.
 633
 634         my $class = shift;
 635         my ($databaseinfo, %databaseinfo);
 636         my ($sqldata, @sqldata);
 637
 638         $error = "";
 639         $errorext = "";
 640
 641         $string_handle = $database_handle->prepare('SELECT name, description, notes, categories, kiriwrite_version_major, kiriwrite_version_minor, kiriwrite_version_revision FROM kiriwrite_database_info LIMIT 1') or (
 642                 $error = "DatabaseError", $errorext = $database_handle->errstr, return
 643         );
 644         $string_handle->execute();
 645
 646         @sqldata = $string_handle->fetchrow_array();
 647
 648         # Process the database information into a hash.
 649
 650         %databaseinfo = (
 651                 "DatabaseName"  => $sqldata[0],
 652                 "Description"   => $sqldata[1],
 653                 "Notes"         => $sqldata[2],
 654                 "Categories"    => $sqldata[3],
 655                 "Major"         => $sqldata[4],
 656                 "Minor"         => $sqldata[5],
 657                 "Revision"      => $sqldata[6]
 658         );
 659
 660         $string_handle->finish();
 661         undef $string_handle;
 662
 663         return %databaseinfo;
 664
 665 }
 666
 667 sub getseconddatabaseinfo{
 668 #################################################################################
 669 # getseconddatabaseinfo: Get information about the database that pages will be  #
 670 # moved or copied to.                                                           #
 671 #                                                                               #
 672 # Usage:                                                                        #
 673 #                                                                               #
 674 # $dbmodule->getseconddatabaseinfo();                                           #
 675 #################################################################################
 676
 677         # Get the database information.
 678
 679         my $class = shift;
 680         my ($databaseinfo, %databaseinfo);
 681         my ($sqldata, @sqldata);
 682
 683         $error = "";
 684         $errorext = "";
 685
 686         $second_string_handle = $second_database_handle->prepare('SELECT name, description, notes, categories, kiriwrite_version_major, kiriwrite_version_minor, kiriwrite_version_revision FROM kiriwrite_database_info LIMIT 1') or (
 687                 $error = "DatabaseError", $errorext = $second_database_handle->errstr, return
 688         );
 689         $second_string_handle->execute();
 690
 691         @sqldata = $second_string_handle->fetchrow_array();
 692
 693         # Process the database information into a hash.
 694
 695         %databaseinfo = (
 696                 "DatabaseName"  => $sqldata[0],
 697                 "Description"   => $sqldata[1],
 698                 "Notes"         => $sqldata[2],
 699                 "Categories"    => $sqldata[3],
 700                 "Major"         => $sqldata[4],
 701                 "Minor"         => $sqldata[5],
 702                 "Revision"      => $sqldata[6]
 703         );
 704
 705         $second_string_handle->finish();
 706         undef $second_string_handle;
 707
 708         return %databaseinfo;
 709
 710 }
 711
 712 sub adddatabase{
 713 #################################################################################
 714 # adddatabase: Adds a Kiriwrite database.                                       #
 715 #                                                                               #
 716 # Usage:                                                                        #
 717 #                                                                               #
 718 # $dbmodule->adddatabase(options);                                              #
 719 #                                                                               #
 720 # options       Specifies the following options in any order.                   #
 721 #                                                                               #
 722 # DatabaseFilename      Specifies the database file/shortname to use.           #
 723 # DatabaseName          Specifies the database name to use.                     #
 724 # DatabaseDescription   Specifies the database description to use.              #
 725 # DatabaseNotes         Specifies the database notes to use.                    #
 726 # DatabaseCategories    Specifies the database categories to use.               #
 727 # VersionMajor          Specifies the major version.                            #
 728 # VersionMinor          Specifies the minor version.                            #
 729 # VersionRevision       Specifies the revision version.                         #
 730 #################################################################################
 731
 732         # Get the database that was passed to the subroutine.
 733
 734         $error  = "";
 735         $errorext = "";
 736
 737         my $class       = shift;
 738         my ($passedoptions) = @_;
 739
 740         my $dbfilename          = $passedoptions->{"DatabaseFilename"};
 741         my $dbname              = $passedoptions->{"DatabaseName"};
 742         my $dbdescription       = $passedoptions->{"DatabaseDescription"};
 743         my $dbnotes             = $passedoptions->{"DatabaseNotes"};
 744         my $dbcategories        = $passedoptions->{"DatabaseCategories"};
 745         my $dbmajorver          = $passedoptions->{"VersionMajor"};
 746         my $dbminorver          = $passedoptions->{"VersionMinor"};
 747         my $dbrevisionver       = $passedoptions->{"VersionRevision"};
 748
 749         # Check if the database with the filename given already exists.
 750
 751         my $database_exists     = $class->dbexists($dbfilename);
 752
 753         if ($database_exists eq 0){
 754
 755                 # The database filename exists so set the error value.
 756
 757                 $error = "DatabaseExists";
 758                 return;
 759
 760         }
 761
 762         # Create the database structure.
 763
 764         $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $options{"Directory"} . '/' . $dbfilename . ".db.sqlite");
 765         $database_handle->{unicode} = 1;
 766         $string_handle          = $database_handle->prepare('CREATE TABLE kiriwrite_database_info(
 767                         name varchar(256) primary key,
 768                         description varchar(512),
 769                         notes text,
 770                         categories varchar(512),
 771                         kiriwrite_version_major int(4),
 772                         kiriwrite_version_minor int(4),
 773                         kiriwrite_version_revision int(4)
 774         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 775         $string_handle->execute();
 776
 777         $string_handle  = $database_handle->prepare('CREATE TABLE kiriwrite_database_pages(
 778                         filename varchar(256) primary key,
 779                         pagename varchar(512),
 780                         pagedescription varchar(512),
 781                         pagesection varchar(256),
 782                         pagetemplate varchar(64),
 783                         pagedata text,
 784                         pagesettings int(1),
 785                         lastmodified datetime
 786         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 787         $string_handle->execute();
 788
 789         # Convert the values into SQL query formatted values and add an entry
 790         # to the kiriwrite_database_info table.
 791
 792         $string_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_info (name, description, notes, categories, kiriwrite_version_major, kiriwrite_version_minor, kiriwrite_version_revision) VALUES(
 793                 \'' . $class->convert($dbname) . '\',
 794                 \'' . $class->convert($dbdescription) . '\',
 795                 \'' . $class->convert($dbnotes) . '\',
 796                 \'' . $class->convert($dbcategories) . '\',
 797                 \'' . $class->convert($dbmajorver) . '\',
 798                 \'' . $class->convert($dbminorver) . '\',
 799                 \'' . $class->convert($dbrevisionver) . '\'
 800         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 801         $string_handle->execute();
 802
 803 }
 804
 805 sub editdatabase{
 806 #################################################################################
 807 # editdatabase: Edits a Kiriwrite Database.                                     #
 808 #                                                                               #
 809 # Usage:                                                                        #
 810 #                                                                               #
 811 # $dbmodule->editdatabase(options);                                             #
 812 #                                                                               #
 813 # options               Specifies the following options in any order.           #
 814 #                                                                               #
 815 # NewDatabaseFilename   Specifies the new database filename to use.             #
 816 # DatabaseName          Specifies the new database name.                        #
 817 # DatabaseDescription   Specifies the new database description.                 #
 818 # DatabaseNotes         Specifies the new database notes.                       #
 819 # DatabaseCategories    Specifies the new database categories.                  #
 820 #################################################################################
 821
 822         $error          = "";
 823         $errorext       = "";
 824
 825         my $class       = shift;
 826         my ($passedoptions) = @_;
 827
 828         my $dbnewfilename       = $passedoptions->{"DatabaseNewFilename"};
 829         my $dbname              = $passedoptions->{"DatabaseName"};
 830         my $dbdescription       = $passedoptions->{"DatabaseDescription"};
 831         my $dbnotes             = $passedoptions->{"DatabaseNotes"};
 832         my $dbcategories        = $passedoptions->{"DatabaseCategories"};
 833
 834         # Check if a new database filename has been specified and if a
 835         # new database filename has been specified then change the
 836         # database filename.
 837
 838         if ($database_filename ne $dbnewfilename){
 839
 840                 # A new database filename has been given so check if the output
 841                 # directory has write access.
 842
 843                 if (-r $options{"Directory"}){
 844
 845                         # The directory is readable.
 846
 847                 } else {
 848
 849                         # The directory is not readable so set the error value.
 850
 851                         $error = "DataDirInvalidPermissions";
 852
 853                         return;
 854
 855                 }
 856
 857                 if (-w $options{"Directory"}){
 858
 859                         # The directory is writeable.
 860
 861                 } else {
 862
 863                         # The directory is not writeable so set the error value.
 864
 865                         $error = "DataDirInvalidPermissions";
 866
 867                         return;
 868
 869                 }
 870
 871                 # Check if a database filename already exists before using the
 872                 # new filename.
 873
 874                 my $database_newexists          = $class->dbexists($dbnewfilename);
 875
 876                 if ($database_newexists eq 0){
 877
 878                         # The database filename exists so set the error value.
 879
 880                         $error = "DatabaseExists";
 881                         return;
 882
 883                 }
 884
 885                 # Check if the database can be renamed (has write access).
 886
 887                 my $database_permissions        = $class->dbpermissions($database_filename, 1, 1);
 888
 889                 if ($database_permissions eq 1){
 890
 891                         # The database filename exists so set the error value.
 892
 893                         $error = "InvalidPermissionsSet";
 894                         return;
 895
 896                 }
 897
 898                 # "Disconnect" from the database.
 899
 900                 $database_handle->disconnect();
 901
 902                 # Rename the database.
 903
 904                 ($database_filename)    = $database_filename =~ /^([a-zA-Z0-9.]+)$/;
 905                 ($dbnewfilename)        = $dbnewfilename =~ /^([a-zA-Z0-9.]+)$/;
 906
 907                 rename($options{"Directory"} . '/' . $database_filename . '.db.sqlite', $options{"Directory"} . '/' . $dbnewfilename . '.db.sqlite');
 908
 909                 # Reload the database from the new filename.
 910
 911                 $database_handle = DBI->connect("dbi:SQLite:dbname=" . $options{"Directory"} . '/' . $dbnewfilename . ".db.sqlite");
 912                 $database_handle->{unicode} = 1;
 913                 $database_filename = $dbnewfilename;
 914
 915         }
 916
 917         # Check if the database can be altered with the new data.
 918
 919         my $database_permissions        = $class->dbpermissions($database_filename, 1, 1);
 920
 921         if ($database_permissions eq 1){
 922
 923                 # The database filename exists so set the error value.
 924
 925                 $error = "InvalidPermissionsSet";
 926                 return;
 927
 928         }
 929
 930         # Get the current database information.
 931
 932         $string_handle = $database_handle->prepare('SELECT name FROM kiriwrite_database_info LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 933         $string_handle->execute();
 934
 935         my @database_oldinfo    = $string_handle->fetchrow_array();
 936
 937         my $dboldname           = $database_oldinfo[0];
 938
 939         # Update the database information.
 940
 941         $string_handle = $database_handle->prepare('UPDATE kiriwrite_database_info SET name = \'' . $class->convert($dbname) . '\',
 942         description = \'' . $class->convert($dbdescription) . '\',
 943         notes = \'' . $class->convert($dbnotes) . '\',
 944         categories = \'' . $class->convert($dbcategories) . '\'') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 945         $string_handle->execute();
 946
 947         undef $string_handle;
 948         return;
 949
 950 }
 951
 952 sub deletedatabase{
 953 #################################################################################
 954 # deletedatabase: Deletes a Kiriwrite database.                                 #
 955 #                                                                               #
 956 # Usage:                                                                        #
 957 #                                                                               #
 958 # $dbmodule->deletedatabase(options);                                           #
 959 #                                                                               #
 960 # options       Specifies the following options in any order.                   #
 961 #                                                                               #
 962 # DatabaseName  Specifies the Kiriwrite database to delete.                     #
 963 #################################################################################
 964
 965         $error          = "";
 966         $errorext       = "";
 967
 968         # Get the database filename.
 969
 970         my $class               = shift;
 971         my ($passedoptions)     = shift;
 972
 973         my $databasename        = $passedoptions->{"DatabaseName"};
 974
 975         # Check if the database exists.
 976
 977         my $database_exists             = $class->dbexists($databasename);
 978
 979         if ($database_exists eq 1){
 980
 981                 # The database does not exist so set the error value.
 982
 983                 $error = "DoesNotExist";
 984                 return;
 985
 986         }
 987
 988         # Check if the database permissions are valid.
 989
 990         my $database_permissions        = $class->dbpermissions($databasename);
 991
 992         if ($database_permissions eq 1){
 993
 994                 # The database permissions are invalid so set the error
 995                 # value.
 996
 997                 $error = "InvalidPermissionsSet";
 998                 return;
 999
1000         }
1001
1002         # Delete the database.
1003
1004         ($databasename) = $databasename =~ /^([a-zA-Z0-9.]+)$/;
1005
1006         unlink($options{"Directory"} . '/' . $databasename . '.db.sqlite');
1007
1008 }
1009
1010 sub selectdb{
1011 #################################################################################
1012 # selectdb: Selects the Kiriwrite database.                                     #
1013 #                                                                               #
1014 # Usage:                                                                        #
1015 #                                                                               #
1016 # $dbmodule->connect(options);                                                  #
1017 #                                                                               #
1018 # options       Specifies the following options in any order.                   #
1019 #                                                                               #
1020 # DatabaseName  Specifies the Kiriwrite database to use.                        #
1021 #################################################################################
1022
1023         # Get the database name.
1024
1025         $error = "";
1026         $errorext = "";
1027
1028         my $class = shift;
1029         my ($passedoptions) = @_;
1030         my (%database, $database);
1031
1032         my $dbname = $passedoptions->{"DatabaseName"};
1033
1034         # Check if the database exists.
1035
1036         my $database_exists = $class->dbexists($dbname);
1037
1038         if ($database_exists eq 1){
1039
1040                 # The database does not exist so return an error value
1041                 # saying that the database does not exist.
1042
1043                 $error = "DoesNotExist";
1044
1045                 return;
1046
1047         }
1048
1049         # Check if the database has valid permissions set.
1050
1051         my $database_permissions = $class->dbpermissions($dbname, 1, 0);
1052
1053         if ($database_permissions eq 1){
1054
1055                 # The database has invalid permissions set so return
1056                 # an error value saying that the database has invalid
1057                 # permissions set.
1058
1059                 $error = "InvalidPermissionsSet";
1060
1061                 return;
1062
1063         }
1064
1065         # Connect to the database.
1066
1067         $database_handle = DBI->connect("dbi:SQLite:dbname=" . $options{"Directory"} . '/' . $dbname . ".db.sqlite");
1068         $database_handle->{unicode} = 1;
1069         $database_filename = $dbname;
1070
1071 }
1072
1073 sub selectseconddb{
1074 #################################################################################
1075 # selectseconddb: Selects a second Kiriwrite database for moving and copying    #
1076 # pages to.                                                                     #
1077 #                                                                               #
1078 # Usage:                                                                        #
1079 #                                                                               #
1080 # $dbmodule->selectseconddb(options);                                           #
1081 #                                                                               #
1082 # options       Specifies the following options in any order.                   #
1083 #                                                                               #
1084 # DatabaseName  Specifies the Kiriwrite database to use.                        #
1085 #################################################################################
1086
1087         # Get the database name.
1088
1089         $error = "";
1090         $errorext = "";
1091
1092         my $class = shift;
1093         my ($passedoptions) = @_;
1094         my (%database, $database);
1095
1096         my $dbname = $passedoptions->{"DatabaseName"};
1097
1098         # Check if the database exists.
1099
1100         my $database_exists = $class->dbexists($dbname);
1101
1102         if ($database_exists eq 1){
1103
1104                 # The database does not exist so return an error value
1105                 # saying that the database does not exist.
1106
1107                 $error = "DoesNotExist";
1108
1109                 return;
1110
1111         }
1112
1113         # Check if the database has valid permissions set.
1114
1115         my $database_permissions = $class->dbpermissions($dbname, 1, 0);
1116
1117         if ($database_permissions eq 1){
1118
1119                 # The database has invalid permissions set so return
1120                 # an error value saying that the database has invalid
1121                 # permissions set.
1122
1123                 $error = "InvalidPermissionsSet";
1124
1125                 return;
1126
1127         }
1128
1129         # Connect to the database.
1130
1131         $second_database_handle = DBI->connect("dbi:SQLite:dbname=" . $options{"Directory"} . '/' . $dbname . ".db.sqlite");
1132         $second_database_handle->{unicode} = 1;
1133         $second_database_filename = $dbname;
1134
1135 }
1136
1137 #################################################################################
1138 # Page subroutines.                                                             #
1139 #################################################################################
1140
1141 sub getpagelist{
1142 #################################################################################
1143 # getpagelist: Gets the list of pages from the database.                        #
1144 #                                                                               #
1145 # Usage:                                                                        #
1146 #                                                                               #
1147 # $dbmodule->getpagelist();                                                     #
1148 #################################################################################
1149
1150         $error = "";
1151         $errorext = "";
1152
1153         my $class       = shift;
1154
1155         $string_handle  = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1156         $string_handle->execute();
1157
1158         my @database_pagefilenames;
1159         my @database_pagefilenames_final;
1160
1161         # Process the collected pages.
1162
1163         while (@database_pagefilenames = $string_handle->fetchrow_array){
1164
1165                 # Add each page to the list of pages in the database.
1166
1167                 push(@database_pagefilenames_final, $database_pagefilenames[0]);
1168
1169         }
1170
1171         undef $string_handle;
1172         return @database_pagefilenames_final;
1173
1174 }
1175
1176 sub getpageinfo{
1177 #################################################################################
1178 # getpageinfo: Gets the page information from the filename passed.              #
1179 #                                                                               #
1180 # Usage:                                                                        #
1181 #                                                                               #
1182 # $dbmodule->getpageinfo(options);                                              #
1183 #                                                                               #
1184 # options       Specifies the following options in any order.                   #
1185 #                                                                               #
1186 # PageFilename  Specifies the page filename to get the page information from.   #
1187 # Reduced       Specifies if the reduced version of the page information should #
1188 #               be retrieved.                                                   #
1189 #################################################################################
1190
1191         $error = "";
1192         $errorext = "";
1193
1194         my $class               = shift;
1195         my ($passedoptions)     = shift;
1196         my (%database_page, $database_page);
1197         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1198
1199         my @data_page;
1200         my $page_found = 0;
1201
1202         # Get the page from the database.
1203
1204         my $page_filename       = $passedoptions->{"PageFilename"};
1205         my $page_reduced        = $passedoptions->{"Reduced"};
1206
1207         if (!$page_reduced){
1208
1209                 $page_reduced = 0;
1210
1211         }
1212
1213         if ($page_reduced eq 1){
1214
1215                 $string_handle  = $database_handle->prepare('SELECT filename, pagename, pagedescription, lastmodified FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1216
1217                 $string_handle->execute();
1218
1219                 # Check if the page exists in the database.
1220
1221                 while (@data_page = $string_handle->fetchrow_array()){
1222
1223                         # Get the values from the array.
1224
1225                         $pagefilename           = $data_page[0];
1226                         $pagename               = $data_page[1];
1227                         $pagedescription        = $data_page[2];
1228                         $pagelastmodified       = $data_page[3];
1229
1230                         # Put the values into the page hash.
1231
1232                         %database_page = (
1233                                 "PageFilename"          => $pagefilename,
1234                                 "PageName"              => $pagename,
1235                                 "PageDescription"       => $pagedescription,
1236                                 "PageLastModified"      => $class->dateconvert($pagelastmodified),
1237                         );
1238
1239                         $page_found = 1;
1240
1241                 }
1242
1243
1244         } else {
1245
1246                 $string_handle  = $database_handle->prepare('SELECT filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1247
1248                 $string_handle->execute();
1249
1250                 # Check if the page exists in the database.
1251
1252                 while (@data_page = $string_handle->fetchrow_array()){
1253
1254                         # Get the values from the array.
1255
1256                         $pagefilename           = $data_page[0];
1257                         $pagename               = $data_page[1];
1258                         $pagedescription        = $data_page[2];
1259                         $pagesection            = $data_page[3];
1260                         $pagetemplate           = $data_page[4];
1261                         $pagedata               = $data_page[5];
1262                         $pagesettings           = $data_page[6];
1263                         $pagelastmodified       = $data_page[7];
1264
1265                         # Put the values into the page hash.
1266
1267                         %database_page = (
1268                                 "PageFilename"          => $pagefilename,
1269                                 "PageName"              => $pagename,
1270                                 "PageDescription"       => $pagedescription,
1271                                 "PageSection"           => $pagesection,
1272                                 "PageTemplate"          => $pagetemplate,
1273                                 "PageContent"           => $pagedata,
1274                                 "PageSettings"          => $pagesettings,
1275                                 "PageLastModified"      => $class->dateconvert($pagelastmodified),
1276                         );
1277
1278                         $page_found = 1;
1279
1280                 }
1281
1282         }
1283
1284         # Check if the page did exist.
1285
1286         if (!$page_found){
1287
1288                 $error = "PageDoesNotExist";
1289                 return;
1290
1291         }
1292
1293         undef $string_handle;
1294         return %database_page;
1295
1296 }
1297
1298 sub addpage{
1299 #################################################################################
1300 # addpage: Add a page to the selected database.                                 #
1301 #                                                                               #
1302 # Usage:                                                                        #
1303 #                                                                               #
1304 # $dbmodule->addpage(options);                                                  #
1305 #                                                                               #
1306 # options       Specifies the following options in any order.                   #
1307 #                                                                               #
1308 # PageFilename          Specifies the page filename to use.                     #
1309 # PageName              Specifies the page name to use.                         #
1310 # PageDescription       Specifies the page description to use.                  #
1311 # PageSection           Specifies the page section to use.                      #
1312 # PageTemplate          Specifies the page template to use.                     #
1313 # PageContent           Specifies the page content to use.                      #
1314 # PageSettings          Specifies the page settings to use.                     #
1315 #################################################################################
1316
1317         # Get the data that was passed to the subroutine.
1318
1319         $error = "";
1320         $errorext = "";
1321
1322         my $class               = shift;
1323         my ($passedoptions)     = shift;
1324
1325         my @database_page;
1326         my $page_count = 0;
1327
1328         # Get the values passed to the hash.
1329
1330         my $page_filename       = $passedoptions->{"PageFilename"};
1331         my $page_name           = $passedoptions->{"PageName"};
1332         my $page_description    = $passedoptions->{"PageDescription"};
1333         my $page_section        = $passedoptions->{"PageSection"};
1334         my $page_template       = $passedoptions->{"PageTemplate"};
1335         my $page_content        = $passedoptions->{"PageContent"};
1336         my $page_settings       = $passedoptions->{"PageSettings"};
1337
1338         # Check to see if the filename given already exists
1339         # in the page database.
1340
1341         $string_handle = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1342         $string_handle->execute();
1343
1344         # Check if a page with the filename given really does
1345         # exist.
1346
1347         while (@database_page = $string_handle->fetchrow_array()){
1348
1349                 # A page does exist so increment the count to 1.
1350
1351                 $page_count++;
1352
1353         }
1354
1355         if ($page_count ne 0){
1356
1357                 # The page does exist so set the error value.
1358
1359                 $error = "PageExists";
1360                 return;
1361
1362         }
1363
1364         # Check if certain values are undefined.
1365
1366         if (!$page_name){
1367
1368                 $page_name = "";
1369
1370         }
1371
1372         if (!$page_description){
1373
1374                 $page_description = "";
1375
1376         }
1377
1378         if (!$page_section){
1379
1380                 $page_section = "";
1381
1382         }
1383
1384         if (!$page_content){
1385
1386                 $page_content = "";
1387
1388         }
1389
1390         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1391         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1392
1393         # Add the page to the selected database.
1394
1395         $string_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1396                 \'' . $class->convert($page_filename) . '\',
1397                 \'' . $class->convert($page_name) . '\',
1398                 \'' . $class->convert($page_description) . '\',
1399                 \'' . $class->convert($page_section) . '\',
1400                 \'' . $class->convert($page_template) . '\',
1401                 \'' . $class->convert($page_content) . '\',
1402                 \'' . $class->convert($page_settings) . '\',
1403                 \'' . $class->convert($page_date) . '\'
1404         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1405         $string_handle->execute();
1406
1407         undef $string_handle;
1408
1409 }
1410
1411 sub deletepage{
1412 #################################################################################
1413 # deletepage: Delete a page from the selected database.                         #
1414 #                                                                               #
1415 # Usage:                                                                        #
1416 #                                                                               #
1417 # $dbmodule->deletepage(options)                                                #
1418 #                                                                               #
1419 # options       Specifies the following options in any order.                   #
1420 #                                                                               #
1421 # PageFilename  Specifies the page filename to delete.                          #
1422 #################################################################################
1423
1424         $error = "";
1425         $errorext = "";
1426
1427         # Get the data that was passed to the subroutine.
1428
1429         my $class = shift;
1430         my ($passedoptions) = @_;
1431         my @page_info;
1432         my $page_found = 0;
1433
1434         # Get the page filename.
1435
1436         my $page_filename = $passedoptions->{"PageFilename"};
1437
1438         # Check if the page exists before deleting it.
1439
1440         $string_handle = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1441         $string_handle->execute();
1442
1443         while (@page_info = $string_handle->fetchrow_array()){
1444
1445                 $page_found = 1;
1446
1447         }
1448
1449         # Check if the page really does exist.
1450
1451         if (!$page_found){
1452
1453                 $error = "PageDoesNotExist";
1454                 return;
1455
1456         }
1457
1458         # Delete the page.
1459
1460         $string_handle = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\'') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1461         $string_handle->execute();
1462
1463 }
1464
1465 sub editpage{
1466 #################################################################################
1467 # editpage: Edit a page from the selected database.                             #
1468 #                                                                               #
1469 # Usage:                                                                        #
1470 #                                                                               #
1471 # $dbmodule->editpage(options);                                                 #
1472 #                                                                               #
1473 # options       Specifies the following options in any order.                   #
1474 #                                                                               #
1475 # PageFilename          Specifies the filename to edit.                         #
1476 # PageNewFilename       Specifies the new filename to use.                      #
1477 # PageNewName           Specifies the new page name to use.                     #
1478 # PageNewDescription    Specifies the new page description to use.              #
1479 # PageNewSection        Specifies the new page section to use.                  #
1480 # PageNewTemplate       Specifies the new page template to use.                 #
1481 # PageNewContent        Specifies the new page content to use.                  #
1482 # PageNewSettings       Specifies the new page settings to use.                 #
1483 #################################################################################
1484
1485         $error = "";
1486         $errorext = "";
1487
1488         # Get the values passed to the subroutine.
1489
1490         my $class = shift;
1491         my ($passedoptions) = @_;
1492         my $page_found = 0;
1493         my @page_info;
1494
1495         # Get the data that was passed to the subroutine.
1496
1497         my $page_filename       = $passedoptions->{"PageFilename"};
1498         my $page_newfilename    = $passedoptions->{"PageNewFilename"};
1499         my $page_newname        = $passedoptions->{"PageNewName"};
1500         my $page_newdescription = $passedoptions->{"PageNewDescription"};
1501         my $page_newsection     = $passedoptions->{"PageNewSection"};
1502         my $page_newtemplate    = $passedoptions->{"PageNewTemplate"};
1503         my $page_newcontent     = $passedoptions->{"PageNewContent"};
1504         my $page_newsettings    = $passedoptions->{"PageNewSettings"};
1505
1506         # Check if the page with the filename given exists.
1507
1508         $string_handle = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1509         $string_handle->execute();
1510
1511         # Check if the page really does exist.
1512
1513         while (@page_info = $string_handle->fetchrow_array()){
1514
1515                 # The page information is found.
1516
1517                 $page_found = 1;
1518
1519         }
1520
1521         # Check if the page really does exist.
1522
1523         if (!$page_found){
1524
1525                 $error = "PageDoesNotExist";
1526                 return;
1527
1528         }
1529
1530         # Check if there is a page that already exists with the new
1531         # filename.
1532
1533         $page_found = 0;
1534
1535         if ($page_filename ne $page_newfilename){
1536
1537                 $string_handle = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_newfilename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1538                 $string_handle->execute();
1539
1540                 # Check if a page really is using the new filename.
1541
1542                 while (@page_info = $string_handle->fetchrow_array()){
1543
1544                         # The page information is found.
1545
1546                         $page_found = 1;
1547
1548                 }
1549
1550                 if ($page_found eq 1){
1551
1552                         $error = "PageExists";
1553                         return;
1554
1555                 }
1556
1557         }
1558
1559         # Get the current date.
1560
1561         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1562         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1563
1564         # Edit the selected page.
1565
1566         $string_handle = $database_handle->prepare('UPDATE kiriwrite_database_pages SET filename = \'' . $class->convert($page_newfilename) . '\', pagename = \'' . $class->convert($page_newname) . '\', pagedescription = \'' . $class->convert($page_newdescription) . '\', pagesection = \'' . $class->convert($page_newsection) . '\', pagetemplate = \'' . $class->convert($page_newtemplate) . '\', pagedata = \'' . $class->convert($page_newcontent) . '\', pagedata = \'' . $class->convert($page_newcontent) . '\', pagesettings = \'' . $class->convert($page_newsettings) . '\', lastmodified = \'' . $page_date . '\' WHERE filename = \'' . $class->convert($page_filename) . '\'')  or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1567         $string_handle->execute();
1568
1569 }
1570
1571 sub movepage{
1572 #################################################################################
1573 # movepage: Moves a page from the old database to the new database.             #
1574 #                                                                               #
1575 # Usage:                                                                        #
1576 #                                                                               #
1577 # $dbmodule->movepage(options);                                                 #
1578 #                                                                               #
1579 # options       Specifies the following options in any order.                   #
1580 #                                                                               #
1581 # PageFilename  Specifies the page with the filename to move.                   #
1582 #################################################################################
1583
1584         $error = "";
1585         $errorext = "";
1586
1587         # Get the values passed to the subroutine.
1588
1589         my $class = shift;
1590         my ($passedoptions) = @_;
1591
1592         my (%database_page, $database_page);
1593         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1594         my @page_info;
1595         my $page_found = 0;
1596
1597         # Get the data that was passed to the subroutine.
1598
1599         my $page_filename = $passedoptions->{"PageFilename"};
1600
1601         # Check if the page with the filename given exists.
1602
1603         $string_handle = $database_handle->prepare('SELECT filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "OldDatabaseError", $errorext = $database_handle->errstr, return );
1604         $string_handle->execute();
1605
1606         # Check if the page really does exist.
1607
1608         while (@page_info = $string_handle->fetchrow_array()){
1609
1610                 # Get the values from the array.
1611
1612                 $pagefilename           = $page_info[0];
1613                 $pagename               = $page_info[1];
1614                 $pagedescription        = $page_info[2];
1615                 $pagesection            = $page_info[3];
1616                 $pagetemplate           = $page_info[4];
1617                 $pagedata               = $page_info[5];
1618                 $pagesettings           = $page_info[6];
1619                 $pagelastmodified       = $page_info[7];
1620
1621                 # Put the values into the page hash.
1622
1623                 %database_page = (
1624                         "PageFilename"          => $pagefilename,
1625                         "PageName"              => $pagename,
1626                         "PageDescription"       => $pagedescription,
1627                         "PageSection"           => $pagesection,
1628                         "PageTemplate"          => $pagetemplate,
1629                         "PageContent"           => $pagedata,
1630                         "PageSettings"          => $pagesettings,
1631                         "PageLastModified"      => $pagelastmodified,
1632                 );
1633
1634                 # The page information is found.
1635
1636                 $page_found = 1;
1637
1638         }
1639
1640         # Check if the page really does exist.
1641
1642         if (!$page_found){
1643
1644                 $error = "PageDoesNotExist";
1645                 return;
1646
1647         }
1648
1649         # Check if the page with the filename given already exists in
1650         # the database the page is being moved to.
1651
1652         $page_found = 0;
1653         @page_info = ();
1654
1655         $second_string_handle = $second_database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1656         $second_string_handle->execute();
1657
1658         while (@page_info = $second_string_handle->fetchrow_array()){
1659
1660                 $page_found = 1;
1661
1662         }
1663
1664         # Check if the page really does exist.
1665
1666         if ($page_found){
1667
1668                 $error = "PageAlreadyExists";
1669                 return;
1670
1671         }
1672
1673         # Add the page to the new database.
1674
1675         $second_string_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1676                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1677                 \'' . $class->convert($database_page{"PageName"}) . '\',
1678                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1679                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1680                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1681                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1682                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1683                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1684         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1685         $second_string_handle->execute();
1686
1687         # Delete the page from the old database.
1688
1689         $string_handle = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($database_page{"PageFilename"}) . '\'') or ( $error = "OldDatabaseError", $errorext = $database_handle->errstr, return );
1690         $string_handle->execute();
1691
1692 }
1693
1694 sub copypage{
1695 #################################################################################
1696 # copypage: Copies a page from the old database to the new database.            #
1697 #                                                                               #
1698 # Usage:                                                                        #
1699 #                                                                               #
1700 # $dbmodule->copypage(options);                                                 #
1701 #                                                                               #
1702 # options       Specifies the following options in any order.                   #
1703 #                                                                               #
1704 # PageFilename  Specifies the page with the filename to copy.                   #
1705 #################################################################################
1706
1707         $error = "";
1708         $errorext = "";
1709
1710         # Get the values passed to the subroutine.
1711
1712         my $class = shift;
1713         my ($passedoptions) = @_;
1714
1715         my (%database_page, $database_page);
1716         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1717         my @page_info;
1718         my $page_found = 0;
1719
1720         # Get the data that was passed to the subroutine.
1721
1722         my $page_filename = $passedoptions->{"PageFilename"};
1723
1724         # Check if the page with the filename given exists.
1725
1726         $string_handle = $database_handle->prepare('SELECT filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "OldDatabaseError", $errorext = $database_handle->errstr, return );
1727         $string_handle->execute();
1728
1729         # Check if the page really does exist.
1730
1731         while (@page_info = $string_handle->fetchrow_array()){
1732
1733                 # Get the values from the array.
1734
1735                 $pagefilename           = $page_info[0];
1736                 $pagename               = $page_info[1];
1737                 $pagedescription        = $page_info[2];
1738                 $pagesection            = $page_info[3];
1739                 $pagetemplate           = $page_info[4];
1740                 $pagedata               = $page_info[5];
1741                 $pagesettings           = $page_info[6];
1742                 $pagelastmodified       = $page_info[7];
1743
1744                 # Put the values into the page hash.
1745
1746                 %database_page = (
1747                         "PageFilename"          => $pagefilename,
1748                         "PageName"              => $pagename,
1749                         "PageDescription"       => $pagedescription,
1750                         "PageSection"           => $pagesection,
1751                         "PageTemplate"          => $pagetemplate,
1752                         "PageContent"           => $pagedata,
1753                         "PageSettings"          => $pagesettings,
1754                         "PageLastModified"      => $pagelastmodified,
1755                 );
1756
1757                 # The page information is found.
1758
1759                 $page_found = 1;
1760
1761         }
1762
1763         # Check if the page really does exist.
1764
1765         if (!$page_found){
1766
1767                 $error = "PageDoesNotExist";
1768                 return;
1769
1770         }
1771
1772         # Check if the page with the filename given already exists in
1773         # the database the page is being moved to.
1774
1775         $page_found = 0;
1776         @page_info = ();
1777
1778         $second_string_handle = $second_database_handle->prepare('SELECT filename FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1779         $second_string_handle->execute();
1780
1781         while (@page_info = $second_string_handle->fetchrow_array()){
1782
1783                 $page_found = 1;
1784
1785         }
1786
1787         # Check if the page really does exist.
1788
1789         if ($page_found){
1790
1791                 $error = "PageAlreadyExists";
1792                 return;
1793
1794         }
1795
1796         # Add the page to the new database.
1797
1798         $second_string_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1799                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1800                 \'' . $class->convert($database_page{"PageName"}) . '\',
1801                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1802                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1803                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1804                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1805                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1806                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1807         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1808         $second_string_handle->execute();
1809
1810 }
1811
1812 #################################################################################
1813 # Filter subroutines.                                                           #
1814 #################################################################################
1815
1816 sub connectfilter{
1817 #################################################################################
1818 # connectfilter: Connect to the filter database.                                #
1819 #                                                                               #
1820 # Usage:                                                                        #
1821 #                                                                               #
1822 # $dbmodule->connectfilter(missingignore);                                      #
1823 #                                                                               #
1824 # missingignore Ignore error about database being missing.                      #
1825 #################################################################################
1826
1827         $error = "";
1828         $errorext = "";
1829
1830         my $class = shift;
1831         my $ignoremissing = shift;
1832
1833         # Check if the template database exists.
1834
1835         my $filterdatabase_exists = main::kiriwrite_fileexists("filters.db.sqlite");
1836
1837         if ($filterdatabase_exists eq 1){
1838
1839                 $filterdb_exists = 0;
1840
1841                 if (!$ignoremissing){
1842
1843                         $error = "FilterDatabaseDoesNotExist";
1844                         return;
1845
1846                 }
1847
1848         }
1849
1850         # Check if the permission settings for the template database are valid.
1851
1852         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 0);
1853
1854         if ($filterdb_permissions eq 1){
1855
1856                 # The template database has invalid permissions set
1857                 # so return an error value.
1858
1859                 if (!$ignoremissing){
1860
1861                         $error = "FilterDatabaseInvalidPermissionsSet";
1862                         return;
1863
1864                 }
1865
1866         }
1867
1868         # Connect to the template database.
1869
1870         $filterdb_database_handle = DBI->connect("dbi:SQLite:dbname=filters.db.sqlite");
1871         $filterdb_database_handle->{unicode} = 1;
1872         $filterdb_loaded = 1;
1873
1874 }
1875
1876 sub disconnectfilter{
1877 #################################################################################
1878 # disconnectfilter: Disconnect from the filter database.                        #
1879 #                                                                               #
1880 # Usage:                                                                        #
1881 #                                                                               #
1882 # $dbmodule->disconnectfilter();                                                #
1883 #################################################################################
1884
1885         # Disconnect the template database.
1886
1887         if ($filterdb_loaded eq 1){
1888
1889                 undef $filterdb_string_handle;
1890                 $filterdb_database_handle->disconnect();
1891
1892         }
1893
1894 }
1895
1896 sub getfilterlist{
1897 #################################################################################
1898 # getfilterlist: Gets the list of filters in the filter database.               #
1899 #                                                                               #
1900 # Usage:                                                                        #
1901 #                                                                               #
1902 # $dbmodule->getfilterlist();                                                   #
1903 #################################################################################
1904
1905         $error = "";
1906         $errorext = "";
1907
1908         my @filter_list;
1909         my @filter_data;
1910
1911         # Get the list of filters available.
1912
1913         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY priority ASC') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
1914         $filterdb_string_handle->execute();
1915
1916         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
1917
1918                 # Add the filter to the list of available filters.
1919
1920                 push(@filter_list, $filter_data[0]);
1921
1922         }
1923
1924         undef $filterdb_string_handle;
1925         return @filter_list;
1926
1927 }
1928
1929 sub getfilterinfo{
1930 #################################################################################
1931 # getfilterinfo: Gets information about the filter.                             #
1932 #                                                                               #
1933 # Usage:                                                                        #
1934 #                                                                               #
1935 # $dbmodule->getfilterinfo(options);                                            #
1936 #                                                                               #
1937 # options       Specifies the following options in any order.                   #
1938 #                                                                               #
1939 # FilterID      Specifies the filter ID number to get information from.         #
1940 #################################################################################
1941
1942         $error = "";
1943         $errorext = "";
1944
1945         # Get the values passed to the subroutine.
1946
1947         my $class               = shift;
1948         my ($passedoptions)     = @_;
1949
1950         my %filter_info;
1951         my $filter_exists       = 0;
1952         my @filter_data;
1953
1954         # Get the values that are in the hash.
1955
1956         my $filter_id           = $passedoptions->{"FilterID"};
1957
1958         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id, priority, findsetting, replacesetting, notes FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
1959         $filterdb_string_handle->execute();
1960
1961         # Get the filter information.
1962
1963         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
1964
1965                 $filter_info{"FilterID"}        = $filter_data[0];
1966                 $filter_info{"FilterPriority"}  = $filter_data[1];
1967                 $filter_info{"FilterFind"}      = $filter_data[2];
1968                 $filter_info{"FilterReplace"}   = $filter_data[3];
1969                 $filter_info{"FilterNotes"}     = $filter_data[4];
1970
1971                 $filter_exists = 1;
1972
1973         }
1974
1975         # Check if the filter exists.
1976
1977         if (!$filter_exists){
1978
1979                 # The filter does not exist so return
1980                 # an error value.
1981
1982                 $error = "FilterDoesNotExist";
1983                 return;
1984
1985         }
1986
1987         # Return the filter information.
1988
1989         undef $filterdb_string_handle;
1990         return %filter_info;
1991
1992 }
1993
1994 sub addfilter{
1995 #################################################################################
1996 # addfilter: Adds a filter to the filter database.                              #
1997 #                                                                               #
1998 # Usage:                                                                        #
1999 #                                                                               #
2000 # $dbmodule->addfilter(options);                                                #
2001 #                                                                               #
2002 # options       Specifies the following options in any order.                   #
2003 #                                                                               #
2004 # FindFilter    Specifies the find filter to add.                               #
2005 # ReplaceFilter Specifies the replace filter to add.                            #
2006 # Priority      Specifies the filter priority to use.                           #
2007 # Notes         Specifies the notes to use.                                     #
2008 #################################################################################
2009
2010         $error = "";
2011         $errorext = "";
2012
2013         # Get the values passed to the subroutine.
2014
2015         my $class = shift;
2016         my ($passedoptions) = @_;
2017
2018         # Define some variables for later.
2019
2020         my @database_filters;
2021         my @filterid_list;
2022         my @filterid_check;
2023         my $nofiltertable = 0;
2024         my $filter_found = 0;
2025         my $filter_count = 0;
2026         my $filter_id;
2027         my $new_id;
2028
2029         # Get the values from the hash.
2030
2031         my $filter_find         = $passedoptions->{"FindFilter"};
2032         my $filter_replace      = $passedoptions->{"ReplaceFilter"};
2033         my $filter_priority     = $passedoptions->{"Priority"};
2034         my $filter_notes        = $passedoptions->{"Notes"};
2035
2036         # Check if the filter database permissions are valid.
2037
2038         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
2039         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
2040
2041         if ($filterdb_permissions eq 1){
2042
2043                 if ($filterdb_exists eq 0){
2044                         $error = "FilterDatabaseInvalidPermissionsSet";
2045                         return;
2046                 }
2047
2048         }
2049
2050         # Check if certain values are undefined and if they
2051         # are then set them blank.
2052
2053         if (!$filter_find){
2054
2055                 $filter_find = "";
2056
2057         }
2058
2059         if (!$filter_replace){
2060
2061                 $filter_replace = "";
2062
2063         }
2064
2065         if (!$filter_priority){
2066
2067                 $filter_priority = 1;
2068
2069         }
2070
2071         if (!$filter_notes){
2072
2073                 $filter_notes = "";
2074
2075         }
2076
2077         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2078
2079         if ($directory_permissions eq 1 && $filterdb_exists){
2080
2081                 # The template database cannot be created because of invalid directory
2082                 # permissions so return an error value.
2083
2084                 $error = "FilterDatabaseFileUncreateable";
2085                 return;
2086
2087         }
2088
2089         # Check if the filter table exists.
2090
2091         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY id ASC') or ( $nofiltertable = 1 );
2092
2093         # Check if there is really no filter table.
2094
2095         if ($nofiltertable){
2096
2097                 # Create the filter database table.
2098
2099                 $filterdb_string_handle = $filterdb_database_handle->prepare('CREATE TABLE kiriwrite_filters (
2100                         id int(7) primary key,
2101                         priority int(5),
2102                         findsetting varchar(1024),
2103                         replacesetting varchar(1024),
2104                         notes text
2105                 )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2106                 $filterdb_string_handle->execute();
2107
2108         }
2109
2110         # Find the lowest filter identification number available.
2111
2112         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY id ASC') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2113         $filterdb_string_handle->execute();
2114
2115         while (@database_filters = $filterdb_string_handle->fetchrow_array()){
2116
2117                 $filter_id      = $database_filters[0];
2118
2119                 # Add the filter identification to the list of filter IDs.
2120
2121                 push(@filterid_list, $filter_id);
2122
2123         }
2124
2125         $filter_id = "";
2126
2127         # Process each filter looking for a blank available filter.
2128
2129         foreach $filter_id (@filterid_list){
2130
2131                 # Check the next filter ID to see if it's blank.
2132
2133                 $new_id = $filter_id + 1;
2134
2135                 $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters WHERE id = \'' . $class->convert($new_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2136                 $filterdb_string_handle->execute();
2137
2138                 # Get the filter identification number.
2139
2140                 while (@filterid_check = $filterdb_string_handle->fetchrow_array()){
2141
2142                         $filter_found = 1;
2143
2144                 }
2145
2146                 # Check if a filter was found.
2147
2148                 if (!$filter_found){
2149
2150                         # No filter was found using this ID so exit the loop.
2151
2152                         last;
2153
2154                 }
2155
2156                 # Increment the filter count and reset the filter found value.
2157
2158                 $filter_count++;
2159                 $filter_found = 0;
2160                 $new_id = 0;
2161
2162         }
2163
2164         # Check if there were any filters in the filter database.
2165
2166         if (!$filter_count && !$new_id){
2167
2168                 # There were no filters in the filter database so set
2169                 # the new filter identification value to 1.
2170
2171                 $new_id = 1;
2172
2173         }
2174
2175         # Add the filter to the filter database.
2176
2177         $filterdb_string_handle = $filterdb_database_handle->prepare('INSERT INTO kiriwrite_filters (id, priority, findsetting, replacesetting, notes) VALUES (
2178                 \'' . $class->convert($new_id) . '\',
2179                 \'' . $class->convert($filter_priority) . '\',
2180                 \'' . $class->convert($filter_find) . '\',
2181                 \'' . $class->convert($filter_replace) .'\',
2182                 \'' . $class->convert($filter_notes) . '\'
2183         )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2184         $filterdb_string_handle->execute();
2185
2186 }
2187
2188 sub editfilter{
2189 #################################################################################
2190 # editfilter: Edits a filter in the filter database.                            #
2191 #                                                                               #
2192 # Usage:                                                                        #
2193 #                                                                               #
2194 # $dbmodule->editfilter(options);                                               #
2195 #                                                                               #
2196 # options       Specifies the following options in any order.                   #
2197 #                                                                               #
2198 # FilterID              Specifies the filter to edit.                           #
2199 # NewFindFilter         Specifies the new find filter setting.                  #
2200 # NewReplaceFilter      Specifies the new replace filter setting.               #
2201 # NewFilterPriority     Specifies the new filter priority setting.              #
2202 # NewFilterNotes        Specifies the new notes for the filter.                 #
2203 #################################################################################
2204
2205         $error = "";
2206         $errorext = "";
2207
2208         # Get the values passed to the subroutine.
2209
2210         my $class = shift;
2211         my ($passedoptions) = @_;
2212
2213         my @filter_data;
2214         my $filter_exists = 1;
2215         my $blankfile = 0;
2216
2217         # Get the values from the hash.
2218
2219         my $filter_id           = $passedoptions->{"FilterID"};
2220         my $filter_newfind      = $passedoptions->{"NewFindFilter"};
2221         my $filter_newreplace   = $passedoptions->{"NewReplaceFilter"};
2222         my $filter_newpriority  = $passedoptions->{"NewFilterPriority"};
2223         my $filter_newnotes     = $passedoptions->{"NewFilterNotes"};
2224
2225         # Check if the filter database permissions are valid.
2226
2227         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
2228         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
2229
2230         if ($filterdb_permissions eq 1){
2231
2232                 if ($filterdb_exists eq 0){
2233                         $error = "FilterDatabaseInvalidPermissionsSet";
2234                         return;
2235                 }
2236
2237         }
2238
2239         # Check if the filter exists before editing it.
2240
2241         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2242         $filterdb_string_handle->execute();
2243
2244         # Check if the filter exists.
2245
2246         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
2247
2248                 $filter_exists = 1;
2249
2250         }
2251
2252         # Check if the filter really does exist.
2253
2254         if (!$filter_exists){
2255
2256                 # The filter does not exist so return
2257                 # an error value.
2258
2259                 $error = "FilterDoesNotExist";
2260                 return;
2261
2262         }
2263
2264         # Edit the selected filter.
2265
2266         $filterdb_string_handle = $filterdb_database_handle->prepare('UPDATE kiriwrite_filters SET
2267                 findsetting = \'' . $class->convert($filter_newfind) . '\',
2268                 replacesetting = \'' . $class->convert($filter_newreplace) . '\',
2269                 priority = \'' . $class->convert($filter_newpriority) . '\',
2270                 notes = \'' . $class->convert($filter_newnotes) . '\'
2271         WHERE id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2272         $filterdb_string_handle->execute();
2273
2274         undef $filterdb_string_handle;
2275         return;
2276
2277 }
2278
2279 sub deletefilter{
2280 #################################################################################
2281 # deletefilter: Deletes a filter from the filter database.                      #
2282 #                                                                               #
2283 # Usage:                                                                        #
2284 #                                                                               #
2285 # $dbmodule->deletefilter(options);                                             #
2286 #                                                                               #
2287 # options       Specifies the following options in any order.                   #
2288 #                                                                               #
2289 # FilterID      Specifies the filter to delete from the filter database.        #
2290 #################################################################################
2291
2292         $error = "";
2293         $errorext = "";
2294
2295         # Get the values passed to the subroutine.
2296
2297         my $class = shift;
2298         my ($passedoptions) = @_;
2299
2300         my $filter_exists = 0;
2301         my @filter_data;
2302
2303         # Get the values from the hash.
2304
2305         my $filter_id           = $passedoptions->{"FilterID"};
2306
2307         # Check if the filter exists before deleting.
2308
2309         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2310         $filterdb_string_handle->execute();
2311
2312         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
2313
2314                 $filter_exists = 1;
2315
2316         }
2317
2318         # Check to see if the filter really does exist.
2319
2320         if (!$filter_exists){
2321
2322                 $error = "FilterDoesNotExist";
2323                 return;
2324
2325         }
2326
2327         # Delete the filter from the filter database.
2328
2329         $filterdb_string_handle = $filterdb_database_handle->prepare('DELETE FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2330         $filterdb_string_handle->execute();
2331
2332         undef $filterdb_string_handle;
2333
2334 }
2335
2336 #################################################################################
2337 # Template subroutines.                                                         #
2338 #################################################################################
2339
2340 sub connecttemplate{
2341 #################################################################################
2342 # connecttemplate: Connect to the template database.                            #
2343 #                                                                               #
2344 # Usage:                                                                        #
2345 #                                                                               #
2346 # $dbmodule->connecttemplate(missingignore);                                    #
2347 #                                                                               #
2348 # missingignore Ignore errror about database being missing.                     #
2349 #################################################################################
2350
2351         $error = "";
2352         $errorext = "";
2353
2354         my $class = shift;
2355         my $ignoremissing = shift;
2356
2357         # Check if the template database exists.
2358
2359         my $templatedatabase_exists = main::kiriwrite_fileexists("templates.db.sqlite");
2360
2361         if ($templatedatabase_exists eq 1){
2362
2363                 $templatedb_exists = 0;
2364
2365                 if (!$ignoremissing){
2366
2367                         $error = "TemplateDatabaseDoesNotExist";
2368                         return;
2369
2370                 }
2371
2372         }
2373
2374         # Check if the permission settings for the template database are valid.
2375
2376         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 0);
2377
2378         if ($templatedb_permissions eq 1){
2379
2380                 # The template database has invalid permissions set
2381                 # so return an error value.
2382
2383                 if (!$ignoremissing){
2384
2385                         $error = "TemplateDatabaseInvalidPermissionsSet";
2386                         return;
2387
2388                 }
2389
2390         }
2391
2392         # Connect to the template database.
2393
2394         $template_database_handle = DBI->connect("dbi:SQLite:dbname=templates.db.sqlite");
2395         $template_database_handle->{unicode} = 1;
2396         $templatedb_loaded = 1;
2397
2398 }
2399
2400 sub disconnecttemplate{
2401 #################################################################################
2402 # disconnecttemplate: Disconnect from the template database.                    #
2403 #                                                                               #
2404 # Usage:                                                                        #
2405 #                                                                               #
2406 # $dbmodule->disconnecttemplate();                                              #
2407 #################################################################################
2408
2409         # Disconnect the template database.
2410
2411         if ($templatedb_loaded eq 1){
2412
2413                 undef $template_string_handle;
2414                 $template_database_handle->disconnect();
2415
2416         }
2417
2418 }
2419
2420 sub gettemplatelist{
2421 #################################################################################
2422 # gettemplatelist: Gets the list of templates.                                  #
2423 #                                                                               #
2424 # Usage:                                                                        #
2425 #                                                                               #
2426 # $dbmodule->gettemplatelist();                                                 #
2427 #################################################################################
2428
2429         $error = "";
2430         $errorext = "";
2431
2432         $template_string_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates ORDER BY filename ASC') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2433         $template_string_handle->execute();
2434
2435         my @database_template;
2436         my @templates_list;
2437         my $template_filename;
2438
2439         while (@database_template = $template_string_handle->fetchrow_array()){
2440
2441                 # Get certain values from the array.
2442
2443                 $template_filename      = $database_template[0];
2444
2445                 # Add the template to the list of templates.
2446
2447                 push(@templates_list, $template_filename);
2448
2449         }
2450
2451         return @templates_list;
2452
2453 }
2454
2455 sub gettemplateinfo{
2456 #################################################################################
2457 # gettemplateinfo: Get information on a template.                               #
2458 #                                                                               #
2459 # Usage:                                                                        #
2460 #                                                                               #
2461 # $dbmodule->gettemplateinfo(options);                                          #
2462 #                                                                               #
2463 # options       Specifies the following options in any order.                   #
2464 #                                                                               #
2465 # TemplateFilename      Specifies the template filename to use.                 #
2466 #################################################################################
2467
2468         $error = "";
2469         $errorext = "";
2470
2471         # Get the data passed to the subroutine.
2472
2473         my $class = shift;
2474         my ($passedoptions) = @_;
2475
2476         my %page_info;
2477         my @template_data;
2478
2479         my $template_filename;
2480         my $template_name;
2481         my $template_description;
2482         my $template_datemodified;
2483         my $template_layout;
2484
2485         my $template_found = 0;
2486
2487         my $filename    = $passedoptions->{"TemplateFilename"};
2488
2489         $template_string_handle = $template_database_handle->prepare('SELECT filename, templatename, templatedescription, templatelayout, datemodified FROM kiriwrite_templates WHERE filename = \'' . $class->convert($filename) . '\'') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2490         $template_string_handle->execute();
2491
2492         while (@template_data = $template_string_handle->fetchrow_array()){
2493
2494                 # Get certain values from the array.
2495
2496                 $template_filename      = $template_data[0];
2497                 $template_name          = $template_data[1];
2498                 $template_description   = $template_data[2];
2499                 $template_layout        = $template_data[3];
2500                 $template_datemodified  = $template_data[4];
2501
2502                 # Process them into the hash.
2503
2504                 %page_info = (
2505                         "TemplateFilename" => $template_filename,
2506                         "TemplateName" => $template_name,
2507                         "TemplateDescription" => $template_description,
2508                         "TemplateLayout" => $template_layout,
2509                         "TemplateLastModified" => $template_datemodified
2510                 );
2511
2512                 $template_found = 1;
2513
2514         }
2515
2516         if ($template_found eq 0){
2517
2518                 # The template was not found in the template database so
2519                 # write an error value.
2520
2521                 $error = "TemplateDoesNotExist";
2522                 return;
2523
2524         }
2525
2526         return %page_info;
2527
2528 }
2529
2530 sub addtemplate{
2531 #################################################################################
2532 # addtemplate: Adds a template to the template database.                        #
2533 #                                                                               #
2534 # Usage:                                                                        #
2535 #                                                                               #
2536 # $dbmodule->addtemplate();                                                     #
2537 #                                                                               #
2538 # options       Specifies the following options in any order.                   #
2539 #                                                                               #
2540 # TemplateFilename      Specifies the new template filename.                    #
2541 # TemplateName          Specifies the new template name.                        #
2542 # TemplateDescription   Specifies the new template description.                 #
2543 # TemplateLayout        Specifies the new template layout.                      #
2544 #################################################################################
2545
2546         $error = "";
2547         $errorext = "";
2548
2549         # Get the data passed to the subroutine.
2550
2551         my $class = shift;
2552         my ($passedoptions) = @_;
2553
2554         my @page_exists;
2555         my $notemplatetable;
2556         my $blankfile = 0;
2557
2558         my $template_filename           = $passedoptions->{"TemplateFilename"};
2559         my $template_name               = $passedoptions->{"TemplateName"};
2560         my $template_description        = $passedoptions->{"TemplateDescription"};
2561         my $template_layout             = $passedoptions->{"TemplateLayout"};
2562
2563         # Check if the template database permissions are valid.
2564
2565         my $templatedb_exists = main::kiriwrite_fileexists("templates.db.sqlite", 1, 1);
2566         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 1);
2567
2568         if ($templatedb_permissions eq 1){
2569
2570                 if ($templatedb_exists eq 0){
2571                         $error = "TemplateDatabaseInvalidPermissionsSet";
2572                         return;
2573                 }
2574
2575         }
2576
2577         # Check if the template already exists before adding.
2578
2579         if ($templatedb_exists eq 0){
2580
2581                 $template_string_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\' LIMIT 1') or ($blankfile = 1);
2582
2583                 if ($blankfile eq 0){
2584
2585                         $template_string_handle->execute();
2586
2587                         while (@page_exists = $template_string_handle->fetchrow_array()){
2588
2589                                 $error = "TemplatePageExists";
2590                                 return;
2591
2592                         }
2593
2594                 }
2595
2596         }
2597
2598         # Get the current date.
2599
2600         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2601
2602         my $template_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2603
2604         # Check if certain values are undefined and if they
2605         # are then set them blank.
2606
2607         if (!$template_name){
2608
2609                 $template_name = "";
2610
2611         }
2612
2613         if (!$template_description){
2614
2615                 $template_description = "";
2616
2617         }
2618
2619         if (!$template_layout){
2620
2621                 $template_layout = "";
2622
2623         }
2624
2625         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2626
2627         if ($directory_permissions eq 1 && $templatedb_exists){
2628
2629                 # The template database cannot be created because of invalid directory
2630                 # permissions so return an error value.
2631
2632                 $error = "TemplateDatabaseUncreateable";
2633                 return;
2634
2635         }
2636
2637         # Check to see if a template can be added.
2638
2639         $template_string_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2640                                 \'' . $class->convert($template_filename) . '\',
2641                                 \'' . $class->convert($template_name) . '\',
2642                                 \'' . $class->convert($template_description) . '\',
2643                                 \'' . $class->convert($template_layout) . '\',
2644                                 \'' . $class->convert($template_date) . '\'
2645         )') or ( $notemplatetable = 1 );
2646
2647         if (!$notemplatetable){
2648
2649                 $template_string_handle->execute();
2650
2651         }
2652
2653         # Check to see if there is no template table and attempt to create one.
2654
2655         if ($notemplatetable){
2656
2657                 # Create a template table.
2658
2659                 my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2660
2661                 if ($directory_permissions eq 1){
2662
2663                         # The template database cannot be created because of invalid directory
2664                         # permissions so return an error.
2665
2666                         $error = "TemplateDatabaseFileUncreateable";
2667                         return;
2668
2669                 }
2670
2671                 $template_string_handle = $template_database_handle->prepare('create table kiriwrite_templates(
2672                         filename varchar(256) primary key,
2673                         templatename varchar(512),
2674                         templatedescription varchar(512),
2675                         templatelayout text,
2676                         datemodified datetime
2677                 );') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2678                 $template_string_handle->execute();
2679
2680                 $template_string_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2681                                 \'' . $class->convert($template_filename) . '\',
2682                                 \'' . $class->convert($template_name) . '\',
2683                                 \'' . $class->convert($template_description) . '\',
2684                                 \'' . $class->convert($template_layout) . '\',
2685                                 \'' . $class->convert($template_date) . '\'
2686                 )') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2687                 $template_string_handle->execute();
2688
2689         }
2690
2691 }
2692
2693 sub deletetemplate{
2694 #################################################################################
2695 # deletetemplate: Deletes a template from the template database.                #
2696 #                                                                               #
2697 # Usage:                                                                        #
2698 #                                                                               #
2699 # $dbmodule->deletetemplate(options);                                           #
2700 #                                                                               #
2701 # options       Specifies the following options in any order.                   #
2702 #                                                                               #
2703 # TemplateFilename      Specifies the template filename to delete.              #
2704 #################################################################################
2705
2706         $error = "";
2707         $errorext = "";
2708
2709         # Get the data passed to the subroutine.
2710
2711         my $class = shift;
2712         my ($passedoptions) = @_;
2713
2714         my @pagedata;
2715         my $template_filename = $passedoptions->{"TemplateFilename"};
2716         my $template_count = 0;
2717
2718         # Check if the template exists.
2719
2720         $template_string_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\' LIMIT 1') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2721         $template_string_handle->execute();
2722
2723         while (@pagedata = $template_string_handle->fetchrow_array()){
2724
2725                 $template_count++;
2726
2727         }
2728
2729         if ($template_count eq 0){
2730
2731                 # No pages were returned so return an error value.
2732
2733                 $error = "TemplateDoesNotExist";
2734                 return;
2735
2736         }
2737
2738         # Delete the template from the template database.
2739
2740         $template_string_handle = $template_database_handle->prepare('DELETE FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\'') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2741         $template_string_handle->execute();
2742
2743 }
2744
2745 sub edittemplate{
2746 #################################################################################
2747 # editttemplate: Edits a Kiriwrite template.                                    #
2748 #                                                                               #
2749 # Usage:                                                                        #
2750 #                                                                               #
2751 # $dbmodule->edittemplate(options);                                             #
2752 #                                                                               #
2753 # options       Specifies the following options in any order.                   #
2754 #                                                                               #
2755 # TemplateFilename              Specifies the template filename to edit.        #
2756 # NewTemplateFilename           Specifies the new template filename.            #
2757 # NewTemplateName               Specifies the new template name.                #
2758 # NewTemplateDescription        Specifies the new template description.         #
2759 # NewTemplateLayout             Specifies the new template layout.              #
2760 #################################################################################
2761
2762         # Get the values passed.
2763
2764         my $class = shift;
2765         my ($passedoptions) = @_;
2766         my $template_found = 0;
2767         my @template_info;
2768
2769         # Process the values passed.
2770
2771         my $template_filename           = $passedoptions->{"TemplateFilename"};
2772         my $new_template_filename       = $passedoptions->{"NewTemplateFilename"};
2773         my $new_template_name           = $passedoptions->{"NewTemplateName"};
2774         my $new_template_description    = $passedoptions->{"NewTemplateDescription"};
2775         my $new_template_layout         = $passedoptions->{"NewTemplateLayout"};
2776
2777         # Check if the template database permissions are valid.
2778
2779         my $templatedb_exists = main::kiriwrite_fileexists("templates.db.sqlite", 1, 1);
2780         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 1);
2781
2782         if ($templatedb_permissions eq 1){
2783
2784                 if ($templatedb_exists eq 0){
2785                         $error = "TemplateDatabaseInvalidPermissionsSet";
2786                         return;
2787                 }
2788
2789         }
2790
2791         # Check if the template exists.
2792
2793         $template_string_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\' LIMIT 1') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2794         $template_string_handle->execute();
2795
2796         while (@template_info = $template_string_handle->fetchrow_array()){
2797
2798                 $template_found = 1;
2799
2800         }
2801
2802         # Check to see if the template was found and set an error value if
2803         # it wasn't.
2804
2805         if ($template_found eq 0){
2806
2807                 $error = "TemplateDoesNotExist";
2808                 return;
2809
2810         }
2811
2812         # Get the date and time.
2813
2814         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2815         my $templatenewdate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2816
2817         # Update the template information.
2818
2819         $template_string_handle = $template_database_handle->prepare('UPDATE kiriwrite_templates SET
2820                 filename = \'' . $class->convert($new_template_filename) . '\',
2821                 templatename = \'' . $class->convert($new_template_name) . '\',
2822                 templatedescription = \'' . $class->convert($new_template_description) . '\',
2823                 templatelayout = \'' . $class->convert($new_template_layout) . '\',
2824                 datemodified = \'' . $class->convert($templatenewdate) . '\'
2825                 WHERE filename = \'' . $class->convert($template_filename) . '\'
2826         ') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2827         $template_string_handle->execute();
2828
2829 }
2830
2831 #################################################################################
2832 # General subroutines.                                                          #
2833 #################################################################################
2834
2835 sub connect{
2836 #################################################################################
2837 # connect: Connect to the server.                                               #
2838 #                                                                               #
2839 # Usage:                                                                        #
2840 #                                                                               #
2841 # $dbmodule->connect();                                                         #
2842 #################################################################################
2843
2844         # This function is not needed in this database module.
2845
2846 }
2847
2848 sub disconnect{
2849 #################################################################################
2850 # connect: Disconnect from the server.                                          #
2851 #                                                                               #
2852 # Usage:                                                                        #
2853 #                                                                               #
2854 # $dbmodule->disconnect();                                                      #
2855 #################################################################################
2856
2857         # This function is not needed in this database module.
2858
2859         undef $string_handle;
2860
2861 }
2862
2863 1;