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$//g;
 609                 $database_filename_friendly = $database;
 610
 611                 #$database_filename_length = length($database);
 612                 #$database_filename_friendly = substr($database, 0, $database_filename_length - 3);
 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 #################################################################################
1188
1189         $error = "";
1190         $errorext = "";
1191
1192         my $class               = shift;
1193         my ($passedoptions)     = shift;
1194         my (%database_page, $database_page);
1195         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1196
1197         my @data_page;
1198         my $page_found = 0;
1199
1200         # Get the page from the database.
1201
1202         my $page_filename       = $passedoptions->{"PageFilename"};
1203
1204         $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 );
1205         $string_handle->execute();
1206
1207         # Check if the page exists in the database.
1208
1209         while (@data_page = $string_handle->fetchrow_array()){
1210
1211                 # Get the values from the array.
1212
1213                 $pagefilename           = $data_page[0];
1214                 $pagename               = $data_page[1];
1215                 $pagedescription        = $data_page[2];
1216                 $pagesection            = $data_page[3];
1217                 $pagetemplate           = $data_page[4];
1218                 $pagedata               = $data_page[5];
1219                 $pagesettings           = $data_page[6];
1220                 $pagelastmodified       = $data_page[7];
1221
1222                 # Put the values into the page hash.
1223
1224                 %database_page = (
1225                         "PageFilename"          => $pagefilename,
1226                         "PageName"              => $pagename,
1227                         "PageDescription"       => $pagedescription,
1228                         "PageSection"           => $pagesection,
1229                         "PageTemplate"          => $pagetemplate,
1230                         "PageContent"           => $pagedata,
1231                         "PageSettings"          => $pagesettings,
1232                         "PageLastModified"      => $class->dateconvert($pagelastmodified),
1233                 );
1234
1235                 $page_found = 1;
1236
1237         }
1238
1239         # Check if the page did exist.
1240
1241         if (!$page_found){
1242
1243                 $error = "PageDoesNotExist";
1244                 return;
1245
1246         }
1247
1248         undef $string_handle;
1249         return %database_page;
1250
1251 }
1252
1253 sub addpage{
1254 #################################################################################
1255 # addpage: Add a page to the selected database.                                 #
1256 #                                                                               #
1257 # Usage:                                                                        #
1258 #                                                                               #
1259 # $dbmodule->addpage(options);                                                  #
1260 #                                                                               #
1261 # options       Specifies the following options in any order.                   #
1262 #                                                                               #
1263 # PageFilename          Specifies the page filename to use.                     #
1264 # PageName              Specifies the page name to use.                         #
1265 # PageDescription       Specifies the page description to use.                  #
1266 # PageSection           Specifies the page section to use.                      #
1267 # PageTemplate          Specifies the page template to use.                     #
1268 # PageContent           Specifies the page content to use.                      #
1269 # PageSettings          Specifies the page settings to use.                     #
1270 #################################################################################
1271
1272         # Get the data that was passed to the subroutine.
1273
1274         $error = "";
1275         $errorext = "";
1276
1277         my $class               = shift;
1278         my ($passedoptions)     = shift;
1279
1280         my @database_page;
1281         my $page_count = 0;
1282
1283         # Get the values passed to the hash.
1284
1285         my $page_filename       = $passedoptions->{"PageFilename"};
1286         my $page_name           = $passedoptions->{"PageName"};
1287         my $page_description    = $passedoptions->{"PageDescription"};
1288         my $page_section        = $passedoptions->{"PageSection"};
1289         my $page_template       = $passedoptions->{"PageTemplate"};
1290         my $page_content        = $passedoptions->{"PageContent"};
1291         my $page_settings       = $passedoptions->{"PageSettings"};
1292
1293         # Check to see if the filename given already exists
1294         # in the page database.
1295
1296         $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 );
1297         $string_handle->execute();
1298
1299         # Check if a page with the filename given really does
1300         # exist.
1301
1302         while (@database_page = $string_handle->fetchrow_array()){
1303
1304                 # A page does exist so increment the count to 1.
1305
1306                 $page_count++;
1307
1308         }
1309
1310         if ($page_count ne 0){
1311
1312                 # The page does exist so set the error value.
1313
1314                 $error = "PageExists";
1315                 return;
1316
1317         }
1318
1319         # Check if certain values are undefined.
1320
1321         if (!$page_name){
1322
1323                 $page_name = "";
1324
1325         }
1326
1327         if (!$page_description){
1328
1329                 $page_description = "";
1330
1331         }
1332
1333         if (!$page_section){
1334
1335                 $page_section = "";
1336
1337         }
1338
1339         if (!$page_content){
1340
1341                 $page_content = "";
1342
1343         }
1344
1345         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1346         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1347
1348         # Add the page to the selected database.
1349
1350         $string_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1351                 \'' . $class->convert($page_filename) . '\',
1352                 \'' . $class->convert($page_name) . '\',
1353                 \'' . $class->convert($page_description) . '\',
1354                 \'' . $class->convert($page_section) . '\',
1355                 \'' . $class->convert($page_template) . '\',
1356                 \'' . $class->convert($page_content) . '\',
1357                 \'' . $class->convert($page_settings) . '\',
1358                 \'' . $class->convert($page_date) . '\'
1359         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1360         $string_handle->execute();
1361
1362         undef $string_handle;
1363
1364 }
1365
1366 sub deletepage{
1367 #################################################################################
1368 # deletepage: Delete a page from the selected database.                         #
1369 #                                                                               #
1370 # Usage:                                                                        #
1371 #                                                                               #
1372 # $dbmodule->deletepage(options)                                                #
1373 #                                                                               #
1374 # options       Specifies the following options in any order.                   #
1375 #                                                                               #
1376 # PageFilename  Specifies the page filename to delete.                          #
1377 #################################################################################
1378
1379         $error = "";
1380         $errorext = "";
1381
1382         # Get the data that was passed to the subroutine.
1383
1384         my $class = shift;
1385         my ($passedoptions) = @_;
1386         my @page_info;
1387         my $page_found = 0;
1388
1389         # Get the page filename.
1390
1391         my $page_filename = $passedoptions->{"PageFilename"};
1392
1393         # Check if the page exists before deleting it.
1394
1395         $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 );
1396         $string_handle->execute();
1397
1398         while (@page_info = $string_handle->fetchrow_array()){
1399
1400                 $page_found = 1;
1401
1402         }
1403
1404         # Check if the page really does exist.
1405
1406         if (!$page_found){
1407
1408                 $error = "PageDoesNotExist";
1409                 return;
1410
1411         }
1412
1413         # Delete the page.
1414
1415         $string_handle = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\'') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1416         $string_handle->execute();
1417
1418 }
1419
1420 sub editpage{
1421 #################################################################################
1422 # editpage: Edit a page from the selected database.                             #
1423 #                                                                               #
1424 # Usage:                                                                        #
1425 #                                                                               #
1426 # $dbmodule->editpage(options);                                                 #
1427 #                                                                               #
1428 # options       Specifies the following options in any order.                   #
1429 #                                                                               #
1430 # PageFilename          Specifies the filename to edit.                         #
1431 # PageNewFilename       Specifies the new filename to use.                      #
1432 # PageNewName           Specifies the new page name to use.                     #
1433 # PageNewDescription    Specifies the new page description to use.              #
1434 # PageNewSection        Specifies the new page section to use.                  #
1435 # PageNewTemplate       Specifies the new page template to use.                 #
1436 # PageNewContent        Specifies the new page content to use.                  #
1437 # PageNewSettings       Specifies the new page settings to use.                 #
1438 #################################################################################
1439
1440         $error = "";
1441         $errorext = "";
1442
1443         # Get the values passed to the subroutine.
1444
1445         my $class = shift;
1446         my ($passedoptions) = @_;
1447         my $page_found = 0;
1448         my @page_info;
1449
1450         # Get the data that was passed to the subroutine.
1451
1452         my $page_filename       = $passedoptions->{"PageFilename"};
1453         my $page_newfilename    = $passedoptions->{"PageNewFilename"};
1454         my $page_newname        = $passedoptions->{"PageNewName"};
1455         my $page_newdescription = $passedoptions->{"PageNewDescription"};
1456         my $page_newsection     = $passedoptions->{"PageNewSection"};
1457         my $page_newtemplate    = $passedoptions->{"PageNewTemplate"};
1458         my $page_newcontent     = $passedoptions->{"PageNewContent"};
1459         my $page_newsettings    = $passedoptions->{"PageNewSettings"};
1460
1461         # Check if the page with the filename given exists.
1462
1463         $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 );
1464         $string_handle->execute();
1465
1466         # Check if the page really does exist.
1467
1468         while (@page_info = $string_handle->fetchrow_array()){
1469
1470                 # The page information is found.
1471
1472                 $page_found = 1;
1473
1474         }
1475
1476         # Check if the page really does exist.
1477
1478         if (!$page_found){
1479
1480                 $error = "PageDoesNotExist";
1481                 return;
1482
1483         }
1484
1485         # Check if there is a page that already exists with the new
1486         # filename.
1487
1488         if ($page_filename ne $page_newfilename){
1489
1490                 $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 );
1491                 $string_handle->execute();
1492
1493                 # Check if a page really is using the new filename.
1494
1495                 while (@page_info = $string_handle->fetchrow_array()){
1496
1497                         # The page information is found.
1498
1499                         $page_found = 1;
1500
1501                 }
1502
1503                 if ($page_found eq 1){
1504
1505                         $error = "PageExists";
1506                         return;
1507
1508                 }
1509
1510         }
1511
1512         # Get the current date.
1513
1514         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1515         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1516
1517         # Edit the selected page.
1518
1519         $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 );
1520         $string_handle->execute();
1521
1522 }
1523
1524 sub movepage{
1525 #################################################################################
1526 # movepage: Moves a page from the old database to the new database.             #
1527 #                                                                               #
1528 # Usage:                                                                        #
1529 #                                                                               #
1530 # $dbmodule->movepage(options);                                                 #
1531 #                                                                               #
1532 # options       Specifies the following options in any order.                   #
1533 #                                                                               #
1534 # PageFilename  Specifies the page with the filename to move.                   #
1535 #################################################################################
1536
1537         $error = "";
1538         $errorext = "";
1539
1540         # Get the values passed to the subroutine.
1541
1542         my $class = shift;
1543         my ($passedoptions) = @_;
1544
1545         my (%database_page, $database_page);
1546         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1547         my @page_info;
1548         my $page_found = 0;
1549
1550         # Get the data that was passed to the subroutine.
1551
1552         my $page_filename = $passedoptions->{"PageFilename"};
1553
1554         # Check if the page with the filename given exists.
1555
1556         $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 );
1557         $string_handle->execute();
1558
1559         # Check if the page really does exist.
1560
1561         while (@page_info = $string_handle->fetchrow_array()){
1562
1563                 # Get the values from the array.
1564
1565                 $pagefilename           = $page_info[0];
1566                 $pagename               = $page_info[1];
1567                 $pagedescription        = $page_info[2];
1568                 $pagesection            = $page_info[3];
1569                 $pagetemplate           = $page_info[4];
1570                 $pagedata               = $page_info[5];
1571                 $pagesettings           = $page_info[6];
1572                 $pagelastmodified       = $page_info[7];
1573
1574                 # Put the values into the page hash.
1575
1576                 %database_page = (
1577                         "PageFilename"          => $pagefilename,
1578                         "PageName"              => $pagename,
1579                         "PageDescription"       => $pagedescription,
1580                         "PageSection"           => $pagesection,
1581                         "PageTemplate"          => $pagetemplate,
1582                         "PageContent"           => $pagedata,
1583                         "PageSettings"          => $pagesettings,
1584                         "PageLastModified"      => $pagelastmodified,
1585                 );
1586
1587                 # The page information is found.
1588
1589                 $page_found = 1;
1590
1591         }
1592
1593         # Check if the page really does exist.
1594
1595         if (!$page_found){
1596
1597                 $error = "PageDoesNotExist";
1598                 return;
1599
1600         }
1601
1602         # Check if the page with the filename given already exists in
1603         # the database the page is being moved to.
1604
1605         $page_found = 0;
1606         @page_info = ();
1607
1608         $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 );
1609         $second_string_handle->execute();
1610
1611         while (@page_info = $second_string_handle->fetchrow_array()){
1612
1613                 $page_found = 1;
1614
1615         }
1616
1617         # Check if the page really does exist.
1618
1619         if ($page_found){
1620
1621                 $error = "PageAlreadyExists";
1622                 return;
1623
1624         }
1625
1626         # Add the page to the new database.
1627
1628         $second_string_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1629                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1630                 \'' . $class->convert($database_page{"PageName"}) . '\',
1631                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1632                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1633                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1634                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1635                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1636                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1637         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1638         $second_string_handle->execute();
1639
1640         # Delete the page from the old database.
1641
1642         $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 );
1643         $string_handle->execute();
1644
1645 }
1646
1647 sub copypage{
1648 #################################################################################
1649 # copypage: Copies a page from the old database to the new database.            #
1650 #                                                                               #
1651 # Usage:                                                                        #
1652 #                                                                               #
1653 # $dbmodule->copypage(options);                                                 #
1654 #                                                                               #
1655 # options       Specifies the following options in any order.                   #
1656 #                                                                               #
1657 # PageFilename  Specifies the page with the filename to copy.                   #
1658 #################################################################################
1659
1660         $error = "";
1661         $errorext = "";
1662
1663         # Get the values passed to the subroutine.
1664
1665         my $class = shift;
1666         my ($passedoptions) = @_;
1667
1668         my (%database_page, $database_page);
1669         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1670         my @page_info;
1671         my $page_found = 0;
1672
1673         # Get the data that was passed to the subroutine.
1674
1675         my $page_filename = $passedoptions->{"PageFilename"};
1676
1677         # Check if the page with the filename given exists.
1678
1679         $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 );
1680         $string_handle->execute();
1681
1682         # Check if the page really does exist.
1683
1684         while (@page_info = $string_handle->fetchrow_array()){
1685
1686                 # Get the values from the array.
1687
1688                 $pagefilename           = $page_info[0];
1689                 $pagename               = $page_info[1];
1690                 $pagedescription        = $page_info[2];
1691                 $pagesection            = $page_info[3];
1692                 $pagetemplate           = $page_info[4];
1693                 $pagedata               = $page_info[5];
1694                 $pagesettings           = $page_info[6];
1695                 $pagelastmodified       = $page_info[7];
1696
1697                 # Put the values into the page hash.
1698
1699                 %database_page = (
1700                         "PageFilename"          => $pagefilename,
1701                         "PageName"              => $pagename,
1702                         "PageDescription"       => $pagedescription,
1703                         "PageSection"           => $pagesection,
1704                         "PageTemplate"          => $pagetemplate,
1705                         "PageContent"           => $pagedata,
1706                         "PageSettings"          => $pagesettings,
1707                         "PageLastModified"      => $pagelastmodified,
1708                 );
1709
1710                 # The page information is found.
1711
1712                 $page_found = 1;
1713
1714         }
1715
1716         # Check if the page really does exist.
1717
1718         if (!$page_found){
1719
1720                 $error = "PageDoesNotExist";
1721                 return;
1722
1723         }
1724
1725         # Check if the page with the filename given already exists in
1726         # the database the page is being moved to.
1727
1728         $page_found = 0;
1729         @page_info = ();
1730
1731         $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 );
1732         $second_string_handle->execute();
1733
1734         while (@page_info = $second_string_handle->fetchrow_array()){
1735
1736                 $page_found = 1;
1737
1738         }
1739
1740         # Check if the page really does exist.
1741
1742         if ($page_found){
1743
1744                 $error = "PageAlreadyExists";
1745                 return;
1746
1747         }
1748
1749         # Add the page to the new database.
1750
1751         $second_string_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1752                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1753                 \'' . $class->convert($database_page{"PageName"}) . '\',
1754                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1755                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1756                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1757                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1758                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1759                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1760         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1761         $second_string_handle->execute();
1762
1763 }
1764
1765 #################################################################################
1766 # Filter subroutines.                                                           #
1767 #################################################################################
1768
1769 sub connectfilter{
1770 #################################################################################
1771 # connectfilter: Connect to the filter database.                                #
1772 #                                                                               #
1773 # Usage:                                                                        #
1774 #                                                                               #
1775 # $dbmodule->connectfilter(missingignore);                                      #
1776 #                                                                               #
1777 # missingignore Ignore error about database being missing.                      #
1778 #################################################################################
1779
1780         $error = "";
1781         $errorext = "";
1782
1783         my $class = shift;
1784         my $ignoremissing = shift;
1785
1786         # Check if the template database exists.
1787
1788         my $filterdatabase_exists = main::kiriwrite_fileexists("filters.db.sqlite");
1789
1790         if ($filterdatabase_exists eq 1){
1791
1792                 $filterdb_exists = 0;
1793
1794                 if (!$ignoremissing){
1795
1796                         $error = "FilterDatabaseDoesNotExist";
1797                         return;
1798
1799                 }
1800
1801         }
1802
1803         # Check if the permission settings for the template database are valid.
1804
1805         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 0);
1806
1807         if ($filterdb_permissions eq 1){
1808
1809                 # The template database has invalid permissions set
1810                 # so return an error value.
1811
1812                 if (!$ignoremissing){
1813
1814                         $error = "FilterDatabaseInvalidPermissionsSet";
1815                         return;
1816
1817                 }
1818
1819         }
1820
1821         # Connect to the template database.
1822
1823         $filterdb_database_handle = DBI->connect("dbi:SQLite:dbname=filters.db.sqlite");
1824         $filterdb_database_handle->{unicode} = 1;
1825         $filterdb_loaded = 1;
1826
1827 }
1828
1829 sub disconnectfilter{
1830 #################################################################################
1831 # disconnectfilter: Disconnect from the filter database.                        #
1832 #                                                                               #
1833 # Usage:                                                                        #
1834 #                                                                               #
1835 # $dbmodule->disconnectfilter();                                                #
1836 #################################################################################
1837
1838         # Disconnect the template database.
1839
1840         if ($filterdb_loaded eq 1){
1841
1842                 undef $filterdb_string_handle;
1843                 $filterdb_database_handle->disconnect();
1844
1845         }
1846
1847 }
1848
1849 sub getfilterlist{
1850 #################################################################################
1851 # getfilterlist: Gets the list of filters in the filter database.               #
1852 #                                                                               #
1853 # Usage:                                                                        #
1854 #                                                                               #
1855 # $dbmodule->getfilterlist();                                                   #
1856 #################################################################################
1857
1858         $error = "";
1859         $errorext = "";
1860
1861         my @filter_list;
1862         my @filter_data;
1863
1864         # Get the list of filters available.
1865
1866         $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 );
1867         $filterdb_string_handle->execute();
1868
1869         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
1870
1871                 # Add the filter to the list of available filters.
1872
1873                 push(@filter_list, $filter_data[0]);
1874
1875         }
1876
1877         undef $filterdb_string_handle;
1878         return @filter_list;
1879
1880 }
1881
1882 sub getfilterinfo{
1883 #################################################################################
1884 # getfilterinfo: Gets information about the filter.                             #
1885 #                                                                               #
1886 # Usage:                                                                        #
1887 #                                                                               #
1888 # $dbmodule->getfilterinfo(options);                                            #
1889 #                                                                               #
1890 # options       Specifies the following options in any order.                   #
1891 #                                                                               #
1892 # FilterID      Specifies the filter ID number to get information from.         #
1893 #################################################################################
1894
1895         $error = "";
1896         $errorext = "";
1897
1898         # Get the values passed to the subroutine.
1899
1900         my $class               = shift;
1901         my ($passedoptions)     = @_;
1902
1903         my %filter_info;
1904         my $filter_exists       = 0;
1905         my @filter_data;
1906
1907         # Get the values that are in the hash.
1908
1909         my $filter_id           = $passedoptions->{"FilterID"};
1910
1911         $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 );
1912         $filterdb_string_handle->execute();
1913
1914         # Get the filter information.
1915
1916         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
1917
1918                 $filter_info{"FilterID"}        = $filter_data[0];
1919                 $filter_info{"FilterPriority"}  = $filter_data[1];
1920                 $filter_info{"FilterFind"}      = $filter_data[2];
1921                 $filter_info{"FilterReplace"}   = $filter_data[3];
1922                 $filter_info{"FilterNotes"}     = $filter_data[4];
1923
1924                 $filter_exists = 1;
1925
1926         }
1927
1928         # Check if the filter exists.
1929
1930         if (!$filter_exists){
1931
1932                 # The filter does not exist so return
1933                 # an error value.
1934
1935                 $error = "FilterDoesNotExist";
1936                 return;
1937
1938         }
1939
1940         # Return the filter information.
1941
1942         undef $filterdb_string_handle;
1943         return %filter_info;
1944
1945 }
1946
1947 sub addfilter{
1948 #################################################################################
1949 # addfilter: Adds a filter to the filter database.                              #
1950 #                                                                               #
1951 # Usage:                                                                        #
1952 #                                                                               #
1953 # $dbmodule->addfilter(options);                                                #
1954 #                                                                               #
1955 # options       Specifies the following options in any order.                   #
1956 #                                                                               #
1957 # FindFilter    Specifies the find filter to add.                               #
1958 # ReplaceFilter Specifies the replace filter to add.                            #
1959 # Priority      Specifies the filter priority to use.                           #
1960 # Notes         Specifies the notes to use.                                     #
1961 #################################################################################
1962
1963         $error = "";
1964         $errorext = "";
1965
1966         # Get the values passed to the subroutine.
1967
1968         my $class = shift;
1969         my ($passedoptions) = @_;
1970
1971         # Define some variables for later.
1972
1973         my @database_filters;
1974         my @filterid_list;
1975         my @filterid_check;
1976         my $nofiltertable = 0;
1977         my $filter_found = 0;
1978         my $filter_count = 0;
1979         my $filter_id;
1980         my $new_id;
1981
1982         # Get the values from the hash.
1983
1984         my $filter_find         = $passedoptions->{"FindFilter"};
1985         my $filter_replace      = $passedoptions->{"ReplaceFilter"};
1986         my $filter_priority     = $passedoptions->{"Priority"};
1987         my $filter_notes        = $passedoptions->{"Notes"};
1988
1989         # Check if the filter database permissions are valid.
1990
1991         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
1992         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
1993
1994         if ($filterdb_permissions eq 1){
1995
1996                 if ($filterdb_exists eq 0){
1997                         $error = "FilterDatabaseInvalidPermissionsSet";
1998                         return;
1999                 }
2000
2001         }
2002
2003         # Check if certain values are undefined and if they
2004         # are then set them blank.
2005
2006         if (!$filter_find){
2007
2008                 $filter_find = "";
2009
2010         }
2011
2012         if (!$filter_replace){
2013
2014                 $filter_replace = "";
2015
2016         }
2017
2018         if (!$filter_priority){
2019
2020                 $filter_priority = 1;
2021
2022         }
2023
2024         if (!$filter_notes){
2025
2026                 $filter_notes = "";
2027
2028         }
2029
2030         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2031
2032         if ($directory_permissions eq 1 && $filterdb_exists){
2033
2034                 # The template database cannot be created because of invalid directory
2035                 # permissions so return an error value.
2036
2037                 $error = "FilterDatabaseFileUncreateable";
2038                 return;
2039
2040         }
2041
2042         # Check if the filter table exists.
2043
2044         $filterdb_string_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY id ASC') or ( $nofiltertable = 1 );
2045
2046         # Check if there is really no filter table.
2047
2048         if ($nofiltertable){
2049
2050                 # Create the filter database table.
2051
2052                 $filterdb_string_handle = $filterdb_database_handle->prepare('CREATE TABLE kiriwrite_filters (
2053                         id int(7) primary key,
2054                         priority int(5),
2055                         findsetting varchar(1024),
2056                         replacesetting varchar(1024),
2057                         notes text
2058                 )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2059                 $filterdb_string_handle->execute();
2060
2061         }
2062
2063         # Find the lowest filter identification number available.
2064
2065         $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 );
2066         $filterdb_string_handle->execute();
2067
2068         while (@database_filters = $filterdb_string_handle->fetchrow_array()){
2069
2070                 $filter_id      = $database_filters[0];
2071
2072                 # Add the filter identification to the list of filter IDs.
2073
2074                 push(@filterid_list, $filter_id);
2075
2076         }
2077
2078         $filter_id = "";
2079
2080         # Process each filter looking for a blank available filter.
2081
2082         foreach $filter_id (@filterid_list){
2083
2084                 # Check the next filter ID to see if it's blank.
2085
2086                 $new_id = $filter_id + 1;
2087
2088                 $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 );
2089                 $filterdb_string_handle->execute();
2090
2091                 # Get the filter identification number.
2092
2093                 while (@filterid_check = $filterdb_string_handle->fetchrow_array()){
2094
2095                         $filter_found = 1;
2096
2097                 }
2098
2099                 # Check if a filter was found.
2100
2101                 if (!$filter_found){
2102
2103                         # No filter was found using this ID so exit the loop.
2104
2105                         last;
2106
2107                 }
2108
2109                 # Increment the filter count and reset the filter found value.
2110
2111                 $filter_count++;
2112                 $filter_found = 0;
2113                 $new_id = 0;
2114
2115         }
2116
2117         # Check if there were any filters in the filters database.
2118
2119         if (!$filter_count && !$new_id){
2120
2121                 # There were no filters in the filters database so set
2122                 # the new filter identification value to 1.
2123
2124                 $new_id = 1;
2125
2126         }
2127
2128         # Add the filter to the filter database.
2129
2130         $filterdb_string_handle = $filterdb_database_handle->prepare('INSERT INTO kiriwrite_filters (id, priority, findsetting, replacesetting, notes) VALUES (
2131                 \'' . $class->convert($new_id) . '\',
2132                 \'' . $class->convert($filter_priority) . '\',
2133                 \'' . $class->convert($filter_find) . '\',
2134                 \'' . $class->convert($filter_replace) .'\',
2135                 \'' . $class->convert($filter_notes) . '\'
2136         )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2137         $filterdb_string_handle->execute();
2138
2139 }
2140
2141 sub editfilter{
2142 #################################################################################
2143 # editfilter: Edits a filter in the filter database.                            #
2144 #                                                                               #
2145 # Usage:                                                                        #
2146 #                                                                               #
2147 # $dbmodule->editfilter(options);                                               #
2148 #                                                                               #
2149 # options       Specifies the following options in any order.                   #
2150 #                                                                               #
2151 # FilterID              Specifies the filter to edit.                           #
2152 # NewFindFilter         Specifies the new find filter setting.                  #
2153 # NewReplaceFilter      Specifies the new replace filter setting.               #
2154 # NewFilterPriority     Specifies the new filter priority setting.              #
2155 # NewFilterNotes        Specifies the new notes for the filter.                 #
2156 #################################################################################
2157
2158         $error = "";
2159         $errorext = "";
2160
2161         # Get the values passed to the subroutine.
2162
2163         my $class = shift;
2164         my ($passedoptions) = @_;
2165
2166         my @filter_data;
2167         my $filter_exists = 1;
2168         my $blankfile = 0;
2169
2170         # Get the values from the hash.
2171
2172         my $filter_id           = $passedoptions->{"FilterID"};
2173         my $filter_newfind      = $passedoptions->{"NewFindFilter"};
2174         my $filter_newreplace   = $passedoptions->{"NewReplaceFilter"};
2175         my $filter_newpriority  = $passedoptions->{"NewFilterPriority"};
2176         my $filter_newnotes     = $passedoptions->{"NewFilterNotes"};
2177
2178         # Check if the filter database permissions are valid.
2179
2180         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
2181         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
2182
2183         if ($filterdb_permissions eq 1){
2184
2185                 if ($filterdb_exists eq 0){
2186                         $error = "FilterDatabaseInvalidPermissionsSet";
2187                         return;
2188                 }
2189
2190         }
2191
2192         # Check if the filter exists before editing it.
2193
2194         $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 );
2195         $filterdb_string_handle->execute();
2196
2197         # Check if the filter exists.
2198
2199         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
2200
2201                 $filter_exists = 1;
2202
2203         }
2204
2205         # Check if the filter really does exist.
2206
2207         if (!$filter_exists){
2208
2209                 # The filter does not exist so return
2210                 # an error value.
2211
2212                 $error = "FilterDoesNotExist";
2213                 return;
2214
2215         }
2216
2217         # Edit the selected filter.
2218
2219         $filterdb_string_handle = $filterdb_database_handle->prepare('UPDATE kiriwrite_filters SET
2220                 findsetting = \'' . $class->convert($filter_newfind) . '\',
2221                 replacesetting = \'' . $class->convert($filter_newreplace) . '\',
2222                 priority = \'' . $class->convert($filter_newpriority) . '\',
2223                 notes = \'' . $class->convert($filter_newnotes) . '\'
2224         WHERE id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2225         $filterdb_string_handle->execute();
2226
2227         undef $filterdb_string_handle;
2228         return;
2229
2230 }
2231
2232 sub deletefilter{
2233 #################################################################################
2234 # deletefilter: Deletes a filter from the filter database.                      #
2235 #                                                                               #
2236 # Usage:                                                                        #
2237 #                                                                               #
2238 # $dbmodule->deletefilter(options);                                             #
2239 #                                                                               #
2240 # options       Specifies the following options in any order.                   #
2241 #                                                                               #
2242 # FilterID      Specifies the filter to delete from the filter database.        #
2243 #################################################################################
2244
2245         $error = "";
2246         $errorext = "";
2247
2248         # Get the values passed to the subroutine.
2249
2250         my $class = shift;
2251         my ($passedoptions) = @_;
2252
2253         my $filter_exists = 0;
2254         my @filter_data;
2255
2256         # Get the values from the hash.
2257
2258         my $filter_id           = $passedoptions->{"FilterID"};
2259
2260         # Check if the filter exists before deleting.
2261
2262         $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 );
2263         $filterdb_string_handle->execute();
2264
2265         while (@filter_data = $filterdb_string_handle->fetchrow_array()){
2266
2267                 $filter_exists = 1;
2268
2269         }
2270
2271         # Check to see if the filter really does exist.
2272
2273         if (!$filter_exists){
2274
2275                 $error = "FilterDoesNotExist";
2276                 return;
2277
2278         }
2279
2280         # Delete the filter from the filter database.
2281
2282         $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 );
2283         $filterdb_string_handle->execute();
2284
2285         undef $filterdb_string_handle;
2286
2287 }
2288
2289 #################################################################################
2290 # Template subroutines.                                                         #
2291 #################################################################################
2292
2293 sub connecttemplate{
2294 #################################################################################
2295 # connecttemplate: Connect to the template database.                            #
2296 #                                                                               #
2297 # Usage:                                                                        #
2298 #                                                                               #
2299 # $dbmodule->connecttemplate(missingignore);                                    #
2300 #                                                                               #
2301 # missingignore Ignore errror about database being missing.                     #
2302 #################################################################################
2303
2304         $error = "";
2305         $errorext = "";
2306
2307         my $class = shift;
2308         my $ignoremissing = shift;
2309
2310         # Check if the template database exists.
2311
2312         my $templatedatabase_exists = main::kiriwrite_fileexists("templates.db.sqlite");
2313
2314         if ($templatedatabase_exists eq 1){
2315
2316                 $templatedb_exists = 0;
2317
2318                 if (!$ignoremissing){
2319
2320                         $error = "TemplateDatabaseDoesNotExist";
2321                         return;
2322
2323                 }
2324
2325         }
2326
2327         # Check if the permission settings for the template database are valid.
2328
2329         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 0);
2330
2331         if ($templatedb_permissions eq 1){
2332
2333                 # The template database has invalid permissions set
2334                 # so return an error value.
2335
2336                 if (!$ignoremissing){
2337
2338                         $error = "TemplateDatabaseInvalidPermissionsSet";
2339                         return;
2340
2341                 }
2342
2343         }
2344
2345         # Connect to the template database.
2346
2347         $template_database_handle = DBI->connect("dbi:SQLite:dbname=templates.db.sqlite");
2348         $template_database_handle->{unicode} = 1;
2349         $templatedb_loaded = 1;
2350
2351 }
2352
2353 sub disconnecttemplate{
2354 #################################################################################
2355 # disconnecttemplate: Disconnect from the template database.                    #
2356 #                                                                               #
2357 # Usage:                                                                        #
2358 #                                                                               #
2359 # $dbmodule->disconnecttemplate();                                              #
2360 #################################################################################
2361
2362         # Disconnect the template database.
2363
2364         if ($templatedb_loaded eq 1){
2365
2366                 undef $template_string_handle;
2367                 $template_database_handle->disconnect();
2368
2369         }
2370
2371 }
2372
2373 sub gettemplatelist{
2374 #################################################################################
2375 # gettemplatelist: Gets the list of templates.                                  #
2376 #                                                                               #
2377 # Usage:                                                                        #
2378 #                                                                               #
2379 # $dbmodule->gettemplatelist();                                                 #
2380 #################################################################################
2381
2382         $error = "";
2383         $errorext = "";
2384
2385         $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 );
2386         $template_string_handle->execute();
2387
2388         my @database_template;
2389         my @templates_list;
2390         my $template_filename;
2391
2392         while (@database_template = $template_string_handle->fetchrow_array()){
2393
2394                 # Get certain values from the array.
2395
2396                 $template_filename      = $database_template[0];
2397
2398                 # Add the template to the list of templates.
2399
2400                 push(@templates_list, $template_filename);
2401
2402         }
2403
2404         return @templates_list;
2405
2406 }
2407
2408 sub gettemplateinfo{
2409 #################################################################################
2410 # gettemplateinfo: Get information on a template.                               #
2411 #                                                                               #
2412 # Usage:                                                                        #
2413 #                                                                               #
2414 # $dbmodule->gettemplateinfo(options);                                          #
2415 #                                                                               #
2416 # options       Specifies the following options in any order.                   #
2417 #                                                                               #
2418 # TemplateFilename      Specifies the template filename to use.                 #
2419 #################################################################################
2420
2421         $error = "";
2422         $errorext = "";
2423
2424         # Get the data passed to the subroutine.
2425
2426         my $class = shift;
2427         my ($passedoptions) = @_;
2428
2429         my %page_info;
2430         my @template_data;
2431
2432         my $template_filename;
2433         my $template_name;
2434         my $template_description;
2435         my $template_datemodified;
2436         my $template_layout;
2437
2438         my $template_found = 0;
2439
2440         my $filename    = $passedoptions->{"TemplateFilename"};
2441
2442         $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 );
2443         $template_string_handle->execute();
2444
2445         while (@template_data = $template_string_handle->fetchrow_array()){
2446
2447                 # Get certain values from the array.
2448
2449                 $template_filename      = $template_data[0];
2450                 $template_name          = $template_data[1];
2451                 $template_description   = $template_data[2];
2452                 $template_layout        = $template_data[3];
2453                 $template_datemodified  = $template_data[4];
2454
2455                 # Process them into the hash.
2456
2457                 %page_info = (
2458                         "TemplateFilename" => $template_filename,
2459                         "TemplateName" => $template_name,
2460                         "TemplateDescription" => $template_description,
2461                         "TemplateLayout" => $template_layout,
2462                         "TemplateLastModified" => $template_datemodified
2463                 );
2464
2465                 $template_found = 1;
2466
2467         }
2468
2469         if ($template_found eq 0){
2470
2471                 # The template was not found in the template database so
2472                 # write an error value.
2473
2474                 $error = "TemplateDoesNotExist";
2475                 return;
2476
2477         }
2478
2479         return %page_info;
2480
2481 }
2482
2483 sub addtemplate{
2484 #################################################################################
2485 # addtemplate: Adds a template to the template database.                        #
2486 #                                                                               #
2487 # Usage:                                                                        #
2488 #                                                                               #
2489 # $dbmodule->addtemplate();                                                     #
2490 #                                                                               #
2491 # options       Specifies the following options in any order.                   #
2492 #                                                                               #
2493 # TemplateFilename      Specifies the new template filename.                    #
2494 # TemplateName          Specifies the new template name.                        #
2495 # TemplateDescription   Specifies the new template description.                 #
2496 # TemplateLayout        Specifies the new template layout.                      #
2497 #################################################################################
2498
2499         $error = "";
2500         $errorext = "";
2501
2502         # Get the data passed to the subroutine.
2503
2504         my $class = shift;
2505         my ($passedoptions) = @_;
2506
2507         my @page_exists;
2508         my $notemplatetable;
2509         my $blankfile = 0;
2510
2511         my $template_filename           = $passedoptions->{"TemplateFilename"};
2512         my $template_name               = $passedoptions->{"TemplateName"};
2513         my $template_description        = $passedoptions->{"TemplateDescription"};
2514         my $template_layout             = $passedoptions->{"TemplateLayout"};
2515
2516         # Check if the template database permissions are valid.
2517
2518         my $templatedb_exists = main::kiriwrite_fileexists("templates.db.sqlite", 1, 1);
2519         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 1);
2520
2521         if ($templatedb_permissions eq 1){
2522
2523                 if ($templatedb_exists eq 0){
2524                         $error = "TemplateDatabaseInvalidPermissionsSet";
2525                         return;
2526                 }
2527
2528         }
2529
2530         # Check if the template already exists before adding.
2531
2532         if ($templatedb_exists eq 0){
2533
2534                 $template_string_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\' LIMIT 1') or ($blankfile = 1);
2535
2536                 if ($blankfile eq 0){
2537
2538                         $template_string_handle->execute();
2539
2540                         while (@page_exists = $template_string_handle->fetchrow_array()){
2541
2542                                 $error = "TemplatePageExists";
2543                                 return;
2544
2545                         }
2546
2547                 }
2548
2549         }
2550
2551         # Get the current date.
2552
2553         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2554
2555         my $template_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2556
2557         # Check if certain values are undefined and if they
2558         # are then set them blank.
2559
2560         if (!$template_name){
2561
2562                 $template_name = "";
2563
2564         }
2565
2566         if (!$template_description){
2567
2568                 $template_description = "";
2569
2570         }
2571
2572         if (!$template_layout){
2573
2574                 $template_layout = "";
2575
2576         }
2577
2578         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2579
2580         if ($directory_permissions eq 1 && $templatedb_exists){
2581
2582                 # The template database cannot be created because of invalid directory
2583                 # permissions so return an error value.
2584
2585                 $error = "TemplateDatabaseUncreateable";
2586                 return;
2587
2588         }
2589
2590         # Check to see if a template can be added.
2591
2592         $template_string_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2593                                 \'' . $class->convert($template_filename) . '\',
2594                                 \'' . $class->convert($template_name) . '\',
2595                                 \'' . $class->convert($template_description) . '\',
2596                                 \'' . $class->convert($template_layout) . '\',
2597                                 \'' . $class->convert($template_date) . '\'
2598         )') or ( $notemplatetable = 1 );
2599
2600         if (!$notemplatetable){
2601
2602                 $template_string_handle->execute();
2603
2604         }
2605
2606         # Check to see if there is no template table and attempt to create one.
2607
2608         if ($notemplatetable){
2609
2610                 # Create a template table.
2611
2612         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2613
2614         if ($directory_permissions eq 1){
2615
2616                 # The template database cannot be created because of invalid directory
2617                 # permissions so return an error.
2618
2619                 $error = "TemplateDatabaseFileUncreateable";
2620                 return;
2621
2622         }
2623
2624                 $template_string_handle = $template_database_handle->prepare('create table kiriwrite_templates(
2625                         filename varchar(256) primary key,
2626                         templatename varchar(512),
2627                         templatedescription varchar(512),
2628                         templatelayout text,
2629                         datemodified datetime
2630                 );') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2631                 $template_string_handle->execute();
2632
2633                 $template_string_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2634                                 \'' . $class->convert($template_filename) . '\',
2635                                 \'' . $class->convert($template_name) . '\',
2636                                 \'' . $class->convert($template_description) . '\',
2637                                 \'' . $class->convert($template_layout) . '\',
2638                                 \'' . $class->convert($template_date) . '\'
2639                 )') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2640                 $template_string_handle->execute();
2641
2642         }
2643
2644 }
2645
2646 sub deletetemplate{
2647 #################################################################################
2648 # deletetemplate: Deletes a template from the template database.                #
2649 #                                                                               #
2650 # Usage:                                                                        #
2651 #                                                                               #
2652 # $dbmodule->deletetemplate(options);                                           #
2653 #                                                                               #
2654 # options       Specifies the following options in any order.                   #
2655 #                                                                               #
2656 # TemplateFilename      Specifies the template filename to delete.              #
2657 #################################################################################
2658
2659         $error = "";
2660         $errorext = "";
2661
2662         # Get the data passed to the subroutine.
2663
2664         my $class = shift;
2665         my ($passedoptions) = @_;
2666
2667         my @pagedata;
2668         my $template_filename = $passedoptions->{"TemplateFilename"};
2669         my $template_count = 0;
2670
2671         # Check if the template exists.
2672
2673         $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 );
2674         $template_string_handle->execute();
2675
2676         while (@pagedata = $template_string_handle->fetchrow_array()){
2677
2678                 $template_count++;
2679
2680         }
2681
2682         if ($template_count eq 0){
2683
2684                 # No pages were returned so return an error value.
2685
2686                 $error = "TemplateDoesNotExist";
2687                 return;
2688
2689         }
2690
2691         # Delete the template from the template database.
2692
2693         $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 );
2694         $template_string_handle->execute();
2695
2696 }
2697
2698 sub edittemplate{
2699 #################################################################################
2700 # editttemplate: Edits a Kiriwrite template.                                    #
2701 #                                                                               #
2702 # Usage:                                                                        #
2703 #                                                                               #
2704 # $dbmodule->edittemplate(options);                                             #
2705 #                                                                               #
2706 # options       Specifies the following options in any order.                   #
2707 #                                                                               #
2708 # TemplateFilename              Specifies the template filename to edit.        #
2709 # NewTemplateFilename           Specifies the new template filename.            #
2710 # NewTemplateName               Specifies the new template name.                #
2711 # NewTemplateDescription        Specifies the new template description.         #
2712 # NewTemplateLayout             Specifies the new template layout.              #
2713 #################################################################################
2714
2715         # Get the values passed.
2716
2717         my $class = shift;
2718         my ($passedoptions) = @_;
2719         my $template_found = 0;
2720         my @template_info;
2721
2722         # Process the values passed.
2723
2724         my $template_filename           = $passedoptions->{"TemplateFilename"};
2725         my $new_template_filename       = $passedoptions->{"NewTemplateFilename"};
2726         my $new_template_name           = $passedoptions->{"NewTemplateName"};
2727         my $new_template_description    = $passedoptions->{"NewTemplateDescription"};
2728         my $new_template_layout         = $passedoptions->{"NewTemplateLayout"};
2729
2730         # Check if the template database permissions are valid.
2731
2732         my $templatedb_exists = main::kiriwrite_fileexists("templates.db.sqlite", 1, 1);
2733         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 1);
2734
2735         if ($templatedb_permissions eq 1){
2736
2737                 if ($templatedb_exists eq 0){
2738                         $error = "TemplateDatabaseInvalidPermissionsSet";
2739                         return;
2740                 }
2741
2742         }
2743
2744         # Check if the template exists.
2745
2746         $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 );
2747         $template_string_handle->execute();
2748
2749         while (@template_info = $template_string_handle->fetchrow_array()){
2750
2751                 $template_found = 1;
2752
2753         }
2754
2755         # Check to see if the template was found and set an error value if
2756         # it wasn't.
2757
2758         if ($template_found eq 0){
2759
2760                 $error = "TemplateDoesNotExist";
2761                 return;
2762
2763         }
2764
2765         # Get the date and time.
2766
2767         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2768         my $templatenewdate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2769
2770         # Update the template information.
2771
2772         $template_string_handle = $template_database_handle->prepare('UPDATE kiriwrite_templates SET
2773                 filename = \'' . $class->convert($new_template_filename) . '\',
2774                 templatename = \'' . $class->convert($new_template_name) . '\',
2775                 templatedescription = \'' . $class->convert($new_template_description) . '\',
2776                 templatelayout = \'' . $class->convert($new_template_layout) . '\',
2777                 datemodified = \'' . $class->convert($templatenewdate) . '\'
2778                 WHERE filename = \'' . $class->convert($template_filename) . '\'
2779         ') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2780         $template_string_handle->execute();
2781
2782 }
2783
2784 #################################################################################
2785 # General subroutines.                                                          #
2786 #################################################################################
2787
2788 sub connect{
2789 #################################################################################
2790 # connect: Connect to the server.                                               #
2791 #                                                                               #
2792 # Usage:                                                                        #
2793 #                                                                               #
2794 # $dbmodule->connect();                                                         #
2795 #################################################################################
2796
2797         # This function is not needed in this database module.
2798
2799 }
2800
2801 sub disconnect{
2802 #################################################################################
2803 # connect: Disconnect from the server.                                          #
2804 #                                                                               #
2805 # Usage:                                                                        #
2806 #                                                                               #
2807 # $dbmodule->disconnect();                                                      #
2808 #################################################################################
2809
2810         # This function is not needed in this database module.
2811
2812         undef $string_handle;
2813
2814 }
2815
2816 1;