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.2.0";
  38 my ($options, %options);
  39 my $database_handle;
  40 my $statement_handle;
  41 my $error = "";
  42 my $errorext = "";
  43 my $database_filename;
  44 my $second_database_filename;
  45 my $second_database_handle;
  46 my $second_statement_handle;
  47 my $templatedb_loaded = 0;
  48 my $templatedb_exists = 1;
  49 my $template_statement_handle;
  50 my $template_database_handle;
  51 my $filterdb_loaded = 0;
  52 my $filterdb_exists = 1;
  53 my $filterdb_statement_handle;
  54 my $filterdb_database_handle;
  55
  56
  57 #################################################################################
  58 # Generic Subroutines.                                                          #
  59 #################################################################################
  60
  61 sub new{
  62 #################################################################################
  63 # new: Create an instance of Kiriwrite::Database::SQLite                        #
  64 #                                                                               #
  65 # Usage:                                                                        #
  66 #                                                                               #
  67 # $dbmodule = Kiriwrite::Database::SQLite->new();                               #
  68 #################################################################################
  69
  70         # Get the perl module name.
  71
  72         my $class = shift;
  73         my $self = {};
  74
  75         return bless($self, $class);
  76
  77 }
  78
  79 sub loadsettings{
  80 #################################################################################
  81 # loadsettings: Loads settings into the SQLite database module                  #
  82 #                                                                               #
  83 # Usage:                                                                        #
  84 #                                                                               #
  85 # $dbmodule->loadsettings(Directory, options);                                  #
  86 #                                                                               #
  87 # options       Specifies the following options (in any order).                 #
  88 #                                                                               #
  89 # Directory     Specifies the directory to use for getting databases.           #
  90 # DateTime      Specifies the date and time format to use.                      #
  91 # Server        Specifies the server to use.                                    #
  92 # Database      Specifies the database to use.                                  #
  93 # Username      Specifies the username to use.                                  #
  94 # Password      Specifies the password to use.                                  #
  95 # HashType      Specifies the password hash type to use.                        #
  96 # Port          Specifies the server port to use.                               #
  97 # Protocol      Specifies the protocol to use.                                  #
  98 # TablePrefix   Specifies the table prefix to use.                              #
  99 #################################################################################
 100
 101         # Get the data passed to the subroutine.
 102
 103         my $class = shift;
 104         my ($passedoptions)     = @_;
 105
 106         # Add the directory setting to the list of options (as it's the only
 107         # one needed for this database module).
 108
 109         %options = (
 110                 "Directory"     => $passedoptions->{"Directory"},
 111                 "DateTime"      => $passedoptions->{"DateTime"},
 112         );
 113
 114 }
 115
 116 sub convert{
 117 #################################################################################
 118 # convert: Converts data into SQL formatted data.                               #
 119 #                                                                               #
 120 # Usage:                                                                        #
 121 #                                                                               #
 122 # $dbmodule->convert(data);                                                     #
 123 #                                                                               #
 124 # data          Specifies the data to convert.                                  #
 125 #################################################################################
 126
 127         # Get the data passed to the subroutine.
 128
 129         my $class       = shift;
 130         my $data        = shift;
 131
 132         if (!$data){
 133                 $data = "";
 134         }
 135
 136         $data =~ s/'/''/g;
 137         $data =~ s/\b//g;
 138
 139         return $data;
 140
 141 }
 142
 143 sub dateconvert{
 144 #################################################################################
 145 # dateconvert: Converts a SQL date into a proper date.                          #
 146 #                                                                               #
 147 # Usage:                                                                        #
 148 #                                                                               #
 149 # $dbmodule->dateconvert(date);                                                 #
 150 #                                                                               #
 151 # date          Specifies the date to convert.                                  #
 152 #################################################################################
 153
 154         # Get the date passed to the subroutine.
 155
 156         my $class       = shift;
 157         my $data        = shift;
 158
 159         # Convert the date given into the proper date.
 160
 161         # Create the following varialbes to be used later.
 162
 163         my $date;
 164         my $time;
 165         my $day;
 166         my $day_full;
 167         my $month;
 168         my $month_check;
 169         my $month_full;
 170         my $year;
 171         my $year_short;
 172         my $hour;
 173         my $hour_full;
 174         my $minute;
 175         my $minute_full;
 176         my $second;
 177         my $second_full;
 178         my $seek = 0;
 179         my $timelength;
 180         my $datelength;
 181         my $daylength;
 182         my $secondlength;
 183         my $startchar = 0;
 184         my $char;
 185         my $length;
 186         my $count = 0;
 187
 188         # Split the date and time.
 189
 190         $length = length($data);
 191
 192         if ($length > 0){
 193
 194                 do {
 195
 196                         # Get the character and check if it is a space.
 197
 198                         $char = substr($data, $seek, 1);
 199
 200                         if ($char eq ' '){
 201
 202                                 # The character is a space, so get the date and time.
 203
 204                                 $date           = substr($data, 0, $seek);
 205                                 $timelength     = $length - $seek - 1;
 206                                 $time           = substr($data, $seek + 1, $timelength);
 207
 208                         }
 209
 210                         $seek++;
 211
 212                 } until ($seek eq $length);
 213
 214                 # Get the year, month and date.
 215
 216                 $length = length($date);
 217                 $seek = 0;
 218
 219                 do {
 220
 221                         # Get the character and check if it is a dash.
 222
 223                         $char = substr($date, $seek, 1);
 224
 225                         if ($char eq '-'){
 226
 227                                 # The character is a dash, so get the year, month or day.
 228
 229                                 $datelength = $seek - $startchar;
 230
 231                                 if ($count eq 0){
 232
 233                                         # Get the year from the date.
 234
 235                                         $year           = substr($date, 0, $datelength) + 1900;
 236                                         $startchar      = $seek;
 237                                         $count = 1;
 238
 239                                         # Get the last two characters to get the short year
 240                                         # version.
 241
 242                                         $year_short     = substr($year, 2, 2);
 243
 244                                 } elsif ($count eq 1){
 245
 246                                         # Get the month and day from the date.
 247
 248                                         $month  = substr($date, $startchar + 1, $datelength - 1) + 1;
 249
 250                                         # Check if the month is less then 10, if it is
 251                                         # add a zero to the value.
 252
 253                                         if ($month < 10){
 254
 255                                                 $month_full = '0' . $month;
 256
 257                                         } else {
 258
 259                                                 $month_full = $month;
 260
 261                                         }
 262
 263                                         $startchar      = $seek;
 264                                         $count = 2;
 265
 266                                         $daylength      = $length - $seek + 1;
 267                                         $day            = substr($date, $startchar + 1, $daylength);
 268
 269                                         # Check if the day is less than 10, if it is
 270                                         # add a zero to the value.
 271
 272                                         if ($day < 10){
 273
 274                                                 $day_full       = '0' . $day;
 275
 276                                         } else {
 277
 278                                                 $day_full       = $day;
 279
 280                                         }
 281
 282                                 }
 283
 284                         }
 285
 286                         $seek++;
 287
 288                 } until ($seek eq $length);
 289
 290                 # Get the length of the time value and reset certain
 291                 # values to 0.
 292
 293                 $length = length($time);
 294                 $seek = 0;
 295                 $count = 0;
 296                 $startchar = 0;
 297
 298                 do {
 299
 300                         # Get the character and check if it is a colon.
 301
 302                         $char = substr($time, $seek, 1);
 303
 304                         if ($char eq ':'){
 305
 306                                 # The character is a colon, so get the hour, minute and day.
 307
 308                                 $timelength = $seek - $startchar;
 309
 310                                 if ($count eq 0){
 311
 312                                         # Get the hour from the time.
 313
 314                                         $hour = substr($time, 0, $timelength);
 315                                         $count = 1;
 316                                         $startchar = $seek;
 317
 318                                         # If the hour is less than ten then add a
 319                                         # zero.
 320
 321                                         if ($hour < 10){
 322
 323                                                 $hour_full = '0' . $hour;
 324
 325                                         } else {
 326
 327                                                 $hour_full = $hour;
 328
 329                                         }
 330
 331                                 } elsif ($count eq 1){
 332
 333                                         # Get the minute and second from the time.
 334
 335                                         $minute = substr($time, $startchar + 1, $timelength - 1);
 336                                         $count = 2;
 337
 338                                         # If the minute is less than ten then add a
 339                                         # zero.
 340
 341                                         if ($minute < 10){
 342
 343                                                 $minute_full = '0' . $minute;
 344
 345                                         } else {
 346
 347                                                 $minute_full = $minute;
 348
 349                                         }
 350
 351                                         $startchar = $seek;
 352
 353                                         $secondlength = $length - $seek + 1;
 354                                         $second = substr($time, $startchar + 1, $secondlength);
 355
 356                                         # If the second is less than ten then add a
 357                                         # zero.
 358
 359                                         if ($second < 10){
 360
 361                                                 $second_full = '0' . $second;
 362
 363                                         } else {
 364
 365                                                 $second_full = $second;
 366
 367                                         }
 368
 369                                 }
 370
 371                         }
 372
 373                         $seek++;
 374
 375                 } until ($seek eq $length);
 376
 377                 # Get the setting for displaying the date and time.
 378
 379                 $data = $options{"DateTime"};
 380
 381                 # Process the setting for displaying the date and time
 382                 # using regular expressions
 383
 384                 $data =~ s/DD/$day_full/g;
 385                 $data =~ s/D/$day/g;
 386                 $data =~ s/MM/$month_full/g;
 387                 $data =~ s/M/$month/g;
 388                 $data =~ s/YY/$year/g;
 389                 $data =~ s/Y/$year_short/g;
 390
 391                 $data =~ s/hh/$hour_full/g;
 392                 $data =~ s/h/$hour/g;
 393                 $data =~ s/mm/$minute_full/g;
 394                 $data =~ s/m/$minute/g;
 395                 $data =~ s/ss/$second_full/g;
 396                 $data =~ s/s/$second/g;
 397
 398         }
 399
 400         return $data;
 401
 402 }
 403
 404 sub geterror{
 405 #################################################################################
 406 # geterror: Gets the error message (or extended error message).                 #
 407 #                                                                               #
 408 # Usage:                                                                        #
 409 #                                                                               #
 410 # $dbmodule->geterror(extended);                                                #
 411 #                                                                               #
 412 # Extended      Specifies if the extended error should be retrieved.            #
 413 #################################################################################
 414
 415         # Get the data passed to the subroutine.
 416
 417         my $class       = shift;
 418         my $extended    = shift;
 419
 420         if (!$extended){
 421                 $extended = 0;
 422         }
 423
 424         if (!$errorext){
 425                 $errorext = "";
 426         }
 427
 428         if (!$error){
 429                 $error = "";
 430         }
 431
 432         # Check to see if extended information should be returned.
 433
 434         if ($extended eq 1){
 435
 436                 # Extended information should be returned.
 437
 438                 return $errorext;
 439
 440         } else {
 441
 442                 # Basic information should be returned.
 443
 444                 return $error;
 445
 446         }
 447
 448 }
 449
 450 sub dbpermissions{
 451 #################################################################################
 452 # dbpermissions: Check if the permissions for the database are valid.           #
 453 #                                                                               #
 454 # Usage:                                                                        #
 455 #                                                                               #
 456 # $database->dbpermissions(dbname, read, write);                                #
 457 #                                                                               #
 458 # dbname        Specifies the database name to check.                           #
 459 # read          Check to see if the database can be read.                       #
 460 # write         Check to see if the database can be written.                    #
 461 #################################################################################
 462
 463         # Get the database name, read setting and write setting.
 464
 465         my ($class, $dbname, $readper, $writeper)       = @_;
 466
 467         # Check if the database can be read.
 468
 469         if ($readper){
 470
 471                 if (-r $options{"Directory"} . '/' . $dbname . ".db.sqlite"){
 472
 473                         # The database can be read.
 474
 475                 } else {
 476
 477                         # The database cannot be read, so return a value
 478                         # of 1.
 479
 480                         return 1;
 481
 482                 }
 483
 484         }
 485
 486         # Check if the database can be written.
 487
 488         if ($writeper){
 489
 490                 if (-w $options{"Directory"} . '/' . $dbname . ".db.sqlite"){
 491
 492                         # The database can be read.
 493
 494                 } else {
 495
 496                         # The database cannot be read, so return a value
 497                         # of 1.
 498
 499                         return 1;
 500
 501                 }
 502
 503         }
 504
 505         # No errors have occured while checking so return a value
 506         # of 0.
 507
 508         return 0;
 509
 510 }
 511
 512 sub dbexists{
 513 #################################################################################
 514 # dbexists: Check if the database exists.                                       #
 515 #                                                                               #
 516 # Usage:                                                                        #
 517 #                                                                               #
 518 # $dbmodule->dbexists(dbname);                                                  #
 519 #                                                                               #
 520 # dbname        Specifies the database name to check.                           #
 521 #################################################################################
 522
 523         # Get the value that was passed to the subroutine.
 524
 525         my $class       = shift;
 526         my ($filename)  = @_;
 527
 528         # Check if the filename exists, if it does, return a value of 1, else
 529         # return a value of 0, meaning that the file was not found.
 530
 531         if (-e $options{"Directory"} . '/' . $filename . ".db.sqlite"){
 532
 533                 # Specified file does exist so return a value of 0.
 534
 535                 return 0;
 536
 537         } else {
 538
 539                 # Specified file does not exist so return a value of 1.
 540
 541                 return 1;
 542
 543         }
 544
 545 }
 546
 547 #################################################################################
 548 # Database Subroutines.                                                         #
 549 #################################################################################
 550
 551 sub getdblist{
 552 #################################################################################
 553 # getdblist: Gets the list of available databases.                              #
 554 #                                                                               #
 555 # Usage:                                                                        #
 556 #                                                                               #
 557 # $dbmodule->getdblist();                                                       #
 558 #################################################################################
 559
 560         # Get the list of databases.
 561
 562         my @data_directory;
 563         my @data_directory_final;
 564         my $database;
 565         my $database_filename_length;
 566         my $database_filename_friendly;
 567
 568         # Check if the database directory has valid permission settings.
 569
 570         if (-e $options{"Directory"}){
 571
 572                 # The database directory does exist. So check if
 573                 # the permission settings are valid.
 574
 575                 if (-r $options{"Directory"}){
 576
 577                         # The permission settings for reading the directory
 578                         # are valid.
 579
 580                 } else {
 581
 582                         # The permission settings for reading the directory
 583                         # are invalid so return an error value.
 584
 585                         $error = "DataDirInvalidPermissions";
 586                         return;
 587
 588                 }
 589
 590         } else {
 591
 592                 # The database directory does not exist, so return an
 593                 # error value.
 594
 595                 $error = "DataDirMissing";
 596                 return;
 597
 598         }
 599
 600         opendir(DATADIR, $options{"Directory"});
 601         @data_directory = grep /m*\.db.sqlite$/, readdir(DATADIR);
 602         closedir(DATADIR);
 603
 604         # Process the list of databases.
 605
 606         foreach $database (@data_directory){
 607
 608                 $database =~ s/.db.sqlite$//og;
 609                 $database_filename_friendly = $database;
 610
 611                 #$database_filename_length = length($database);
 612                 #$database_filename_friendly = substr($database, 0, $database_filename_length - 10);
 613                 push(@data_directory_final, $database_filename_friendly);
 614
 615         }
 616
 617         # Return the list of databases.
 618
 619         return @data_directory_final;
 620
 621 }
 622
 623 sub getdatabaseinfo{
 624 #################################################################################
 625 # getdatabaseinfo: Get information about the database.                          #
 626 #                                                                               #
 627 # Usage:                                                                        #
 628 #                                                                               #
 629 # $dbmodule->getdatabaseinfo();                                                 #
 630 #################################################################################
 631
 632         # Get the database information.
 633
 634         my $class = shift;
 635         my ($databaseinfo, %databaseinfo);
 636         my ($sqldata, @sqldata);
 637
 638         $error = "";
 639         $errorext = "";
 640
 641         $statement_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         $statement_handle->execute();
 645
 646         @sqldata = $statement_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         $statement_handle->finish();
 661         undef $statement_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_statement_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_statement_handle->execute();
 690
 691         @sqldata = $second_statement_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_statement_handle->finish();
 706         undef $second_statement_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         $statement_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         $statement_handle->execute();
 776
 777         $statement_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         $statement_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         $statement_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         $statement_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         $statement_handle = $database_handle->prepare('SELECT name FROM kiriwrite_database_info LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
 933         $statement_handle->execute();
 934
 935         my @database_oldinfo    = $statement_handle->fetchrow_array();
 936
 937         my $dboldname           = $database_oldinfo[0];
 938
 939         # Update the database information.
 940
 941         $statement_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         $statement_handle->execute();
 946
 947         undef $statement_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(options);                                              #
1148 #                                                                               #
1149 # options       Specifies the following options in any order.                   #
1150 #                                                                               #
1151 # StartFrom     Start from the specified page in the database.                  #
1152 # Limit         Get the amount of pages given.                                  #
1153 #################################################################################
1154
1155         $error = "";
1156         $errorext = "";
1157
1158         my $class               = shift;
1159         my ($passedoptions)     = shift;
1160
1161         my $start_from  = $passedoptions->{"StartFrom"};
1162         my $limit       = $passedoptions->{"Limit"};
1163
1164         if (defined($start_from)){
1165
1166                 if (!$limit){
1167
1168                         $limit = 0;
1169
1170                 }
1171
1172                 $statement_handle       = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages LIMIT ' . $start_from . ',' . $limit) or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1173                 $statement_handle->execute();
1174
1175         } else {
1176
1177                 $statement_handle       = $database_handle->prepare('SELECT filename FROM kiriwrite_database_pages') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1178                 $statement_handle->execute();
1179
1180         }
1181
1182         my @database_pagefilenames;
1183         my @database_pagefilenames_final;
1184
1185         # Process the collected pages.
1186
1187         while (@database_pagefilenames = $statement_handle->fetchrow_array){
1188
1189                 # Add each page to the list of pages in the database.
1190
1191                 push(@database_pagefilenames_final, $database_pagefilenames[0]);
1192
1193         }
1194
1195         undef $statement_handle;
1196         return @database_pagefilenames_final;
1197
1198 }
1199
1200 sub getpagecount{
1201 #################################################################################
1202 # getpagecount: Get the count of pages that are in the database.                #
1203 #                                                                               #
1204 # Usage:                                                                        #
1205 #                                                                               #
1206 # $dbmodule->getpagecount();                                                    #
1207 #################################################################################
1208
1209         $error = "";
1210         $errorext = "";
1211
1212         my $class       = shift;
1213
1214         $statement_handle       = $database_handle->prepare('SELECT COUNT(*) FROM kiriwrite_database_pages') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return);
1215         $statement_handle->execute();
1216
1217         my $count = $statement_handle->fetchrow_array();
1218
1219         return $count;
1220
1221 }
1222
1223 sub getpageinfo{
1224 #################################################################################
1225 # getpageinfo: Gets the page information from the filename passed.              #
1226 #                                                                               #
1227 # Usage:                                                                        #
1228 #                                                                               #
1229 # $dbmodule->getpageinfo(options);                                              #
1230 #                                                                               #
1231 # options       Specifies the following options in any order.                   #
1232 #                                                                               #
1233 # PageFilename  Specifies the page filename to get the page information from.   #
1234 # Reduced       Specifies if the reduced version of the page information should #
1235 #               be retrieved.                                                   #
1236 #################################################################################
1237
1238         $error = "";
1239         $errorext = "";
1240
1241         my $class               = shift;
1242         my ($passedoptions)     = shift;
1243         my (%database_page, $database_page);
1244         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1245
1246         my @data_page;
1247         my $page_found = 0;
1248
1249         # Get the page from the database.
1250
1251         my $page_filename       = $passedoptions->{"PageFilename"};
1252         my $page_reduced        = $passedoptions->{"Reduced"};
1253
1254         if (!$page_reduced){
1255
1256                 $page_reduced = 0;
1257
1258         }
1259
1260         if ($page_reduced eq 1){
1261
1262                 $statement_handle       = $database_handle->prepare('SELECT filename, pagename, pagedescription, lastmodified FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\' LIMIT 1') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1263
1264                 $statement_handle->execute();
1265
1266                 # Check if the page exists in the database.
1267
1268                 while (@data_page = $statement_handle->fetchrow_array()){
1269
1270                         # Get the values from the array.
1271
1272                         $pagefilename           = $data_page[0];
1273                         $pagename               = $data_page[1];
1274                         $pagedescription        = $data_page[2];
1275                         $pagelastmodified       = $data_page[3];
1276
1277                         # Put the values into the page hash.
1278
1279                         %database_page = (
1280                                 "PageFilename"          => $pagefilename,
1281                                 "PageName"              => $pagename,
1282                                 "PageDescription"       => $pagedescription,
1283                                 "PageLastModified"      => $class->dateconvert($pagelastmodified),
1284                         );
1285
1286                         $page_found = 1;
1287
1288                 }
1289
1290
1291         } else {
1292
1293                 $statement_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 );
1294
1295                 $statement_handle->execute();
1296
1297                 # Check if the page exists in the database.
1298
1299                 while (@data_page = $statement_handle->fetchrow_array()){
1300
1301                         # Get the values from the array.
1302
1303                         $pagefilename           = $data_page[0];
1304                         $pagename               = $data_page[1];
1305                         $pagedescription        = $data_page[2];
1306                         $pagesection            = $data_page[3];
1307                         $pagetemplate           = $data_page[4];
1308                         $pagedata               = $data_page[5];
1309                         $pagesettings           = $data_page[6];
1310                         $pagelastmodified       = $data_page[7];
1311
1312                         # Put the values into the page hash.
1313
1314                         %database_page = (
1315                                 "PageFilename"          => $pagefilename,
1316                                 "PageName"              => $pagename,
1317                                 "PageDescription"       => $pagedescription,
1318                                 "PageSection"           => $pagesection,
1319                                 "PageTemplate"          => $pagetemplate,
1320                                 "PageContent"           => $pagedata,
1321                                 "PageSettings"          => $pagesettings,
1322                                 "PageLastModified"      => $class->dateconvert($pagelastmodified),
1323                         );
1324
1325                         $page_found = 1;
1326
1327                 }
1328
1329         }
1330
1331         # Check if the page did exist.
1332
1333         if (!$page_found){
1334
1335                 $error = "PageDoesNotExist";
1336                 return;
1337
1338         }
1339
1340         undef $statement_handle;
1341         return %database_page;
1342
1343 }
1344
1345 sub addpage{
1346 #################################################################################
1347 # addpage: Add a page to the selected database.                                 #
1348 #                                                                               #
1349 # Usage:                                                                        #
1350 #                                                                               #
1351 # $dbmodule->addpage(options);                                                  #
1352 #                                                                               #
1353 # options       Specifies the following options in any order.                   #
1354 #                                                                               #
1355 # PageFilename          Specifies the page filename to use.                     #
1356 # PageName              Specifies the page name to use.                         #
1357 # PageDescription       Specifies the page description to use.                  #
1358 # PageSection           Specifies the page section to use.                      #
1359 # PageTemplate          Specifies the page template to use.                     #
1360 # PageContent           Specifies the page content to use.                      #
1361 # PageSettings          Specifies the page settings to use.                     #
1362 #################################################################################
1363
1364         # Get the data that was passed to the subroutine.
1365
1366         $error = "";
1367         $errorext = "";
1368
1369         my $class               = shift;
1370         my ($passedoptions)     = shift;
1371
1372         my @database_page;
1373         my $page_count = 0;
1374
1375         # Get the values passed to the hash.
1376
1377         my $page_filename       = $passedoptions->{"PageFilename"};
1378         my $page_name           = $passedoptions->{"PageName"};
1379         my $page_description    = $passedoptions->{"PageDescription"};
1380         my $page_section        = $passedoptions->{"PageSection"};
1381         my $page_template       = $passedoptions->{"PageTemplate"};
1382         my $page_content        = $passedoptions->{"PageContent"};
1383         my $page_settings       = $passedoptions->{"PageSettings"};
1384
1385         # Check to see if the filename given already exists
1386         # in the page database.
1387
1388         $statement_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 );
1389         $statement_handle->execute();
1390
1391         # Check if a page with the filename given really does
1392         # exist.
1393
1394         while (@database_page = $statement_handle->fetchrow_array()){
1395
1396                 # A page does exist so increment the count to 1.
1397
1398                 $page_count++;
1399
1400         }
1401
1402         if ($page_count ne 0){
1403
1404                 # The page does exist so set the error value.
1405
1406                 $error = "PageExists";
1407                 return;
1408
1409         }
1410
1411         # Check if certain values are undefined.
1412
1413         if (!$page_name){
1414
1415                 $page_name = "";
1416
1417         }
1418
1419         if (!$page_description){
1420
1421                 $page_description = "";
1422
1423         }
1424
1425         if (!$page_section){
1426
1427                 $page_section = "";
1428
1429         }
1430
1431         if (!$page_content){
1432
1433                 $page_content = "";
1434
1435         }
1436
1437         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1438         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1439
1440         # Add the page to the selected database.
1441
1442         $statement_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1443                 \'' . $class->convert($page_filename) . '\',
1444                 \'' . $class->convert($page_name) . '\',
1445                 \'' . $class->convert($page_description) . '\',
1446                 \'' . $class->convert($page_section) . '\',
1447                 \'' . $class->convert($page_template) . '\',
1448                 \'' . $class->convert($page_content) . '\',
1449                 \'' . $class->convert($page_settings) . '\',
1450                 \'' . $class->convert($page_date) . '\'
1451         )') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1452         $statement_handle->execute();
1453
1454         undef $statement_handle;
1455
1456 }
1457
1458 sub deletepage{
1459 #################################################################################
1460 # deletepage: Delete a page from the selected database.                         #
1461 #                                                                               #
1462 # Usage:                                                                        #
1463 #                                                                               #
1464 # $dbmodule->deletepage(options)                                                #
1465 #                                                                               #
1466 # options       Specifies the following options in any order.                   #
1467 #                                                                               #
1468 # PageFilename  Specifies the page filename to delete.                          #
1469 #################################################################################
1470
1471         $error = "";
1472         $errorext = "";
1473
1474         # Get the data that was passed to the subroutine.
1475
1476         my $class = shift;
1477         my ($passedoptions) = @_;
1478         my @page_info;
1479         my $page_found = 0;
1480
1481         # Get the page filename.
1482
1483         my $page_filename = $passedoptions->{"PageFilename"};
1484
1485         # Check if the page exists before deleting it.
1486
1487         $statement_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 );
1488         $statement_handle->execute();
1489
1490         while (@page_info = $statement_handle->fetchrow_array()){
1491
1492                 $page_found = 1;
1493
1494         }
1495
1496         # Check if the page really does exist.
1497
1498         if (!$page_found){
1499
1500                 $error = "PageDoesNotExist";
1501                 return;
1502
1503         }
1504
1505         # Delete the page.
1506
1507         $statement_handle = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($page_filename) . '\'') or ( $error = "DatabaseError", $errorext = $database_handle->errstr, return );
1508         $statement_handle->execute();
1509
1510 }
1511
1512 sub editpage{
1513 #################################################################################
1514 # editpage: Edit a page from the selected database.                             #
1515 #                                                                               #
1516 # Usage:                                                                        #
1517 #                                                                               #
1518 # $dbmodule->editpage(options);                                                 #
1519 #                                                                               #
1520 # options       Specifies the following options in any order.                   #
1521 #                                                                               #
1522 # PageFilename          Specifies the filename to edit.                         #
1523 # PageNewFilename       Specifies the new filename to use.                      #
1524 # PageNewName           Specifies the new page name to use.                     #
1525 # PageNewDescription    Specifies the new page description to use.              #
1526 # PageNewSection        Specifies the new page section to use.                  #
1527 # PageNewTemplate       Specifies the new page template to use.                 #
1528 # PageNewContent        Specifies the new page content to use.                  #
1529 # PageNewSettings       Specifies the new page settings to use.                 #
1530 #################################################################################
1531
1532         $error = "";
1533         $errorext = "";
1534
1535         # Get the values passed to the subroutine.
1536
1537         my $class = shift;
1538         my ($passedoptions) = @_;
1539         my $page_found = 0;
1540         my @page_info;
1541
1542         # Get the data that was passed to the subroutine.
1543
1544         my $page_filename       = $passedoptions->{"PageFilename"};
1545         my $page_newfilename    = $passedoptions->{"PageNewFilename"};
1546         my $page_newname        = $passedoptions->{"PageNewName"};
1547         my $page_newdescription = $passedoptions->{"PageNewDescription"};
1548         my $page_newsection     = $passedoptions->{"PageNewSection"};
1549         my $page_newtemplate    = $passedoptions->{"PageNewTemplate"};
1550         my $page_newcontent     = $passedoptions->{"PageNewContent"};
1551         my $page_newsettings    = $passedoptions->{"PageNewSettings"};
1552
1553         # Check if the page with the filename given exists.
1554
1555         $statement_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 );
1556         $statement_handle->execute();
1557
1558         # Check if the page really does exist.
1559
1560         while (@page_info = $statement_handle->fetchrow_array()){
1561
1562                 # The page information is found.
1563
1564                 $page_found = 1;
1565
1566         }
1567
1568         # Check if the page really does exist.
1569
1570         if (!$page_found){
1571
1572                 $error = "PageDoesNotExist";
1573                 return;
1574
1575         }
1576
1577         # Check if there is a page that already exists with the new
1578         # filename.
1579
1580         $page_found = 0;
1581
1582         if ($page_filename ne $page_newfilename){
1583
1584                 $statement_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 );
1585                 $statement_handle->execute();
1586
1587                 # Check if a page really is using the new filename.
1588
1589                 while (@page_info = $statement_handle->fetchrow_array()){
1590
1591                         # The page information is found.
1592
1593                         $page_found = 1;
1594
1595                 }
1596
1597                 if ($page_found eq 1){
1598
1599                         $error = "PageExists";
1600                         return;
1601
1602                 }
1603
1604         }
1605
1606         # Get the current date.
1607
1608         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1609         my $page_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1610
1611         # Edit the selected page.
1612
1613         $statement_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 );
1614         $statement_handle->execute();
1615
1616 }
1617
1618 sub movepage{
1619 #################################################################################
1620 # movepage: Moves a page from the old database to the new database.             #
1621 #                                                                               #
1622 # Usage:                                                                        #
1623 #                                                                               #
1624 # $dbmodule->movepage(options);                                                 #
1625 #                                                                               #
1626 # options       Specifies the following options in any order.                   #
1627 #                                                                               #
1628 # PageFilename  Specifies the page with the filename to move.                   #
1629 #################################################################################
1630
1631         $error = "";
1632         $errorext = "";
1633
1634         # Get the values passed to the subroutine.
1635
1636         my $class = shift;
1637         my ($passedoptions) = @_;
1638
1639         my (%database_page, $database_page);
1640         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1641         my @page_info;
1642         my $page_found = 0;
1643
1644         # Get the data that was passed to the subroutine.
1645
1646         my $page_filename = $passedoptions->{"PageFilename"};
1647
1648         # Check if the page with the filename given exists.
1649
1650         $statement_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 );
1651         $statement_handle->execute();
1652
1653         # Check if the page really does exist.
1654
1655         while (@page_info = $statement_handle->fetchrow_array()){
1656
1657                 # Get the values from the array.
1658
1659                 $pagefilename           = $page_info[0];
1660                 $pagename               = $page_info[1];
1661                 $pagedescription        = $page_info[2];
1662                 $pagesection            = $page_info[3];
1663                 $pagetemplate           = $page_info[4];
1664                 $pagedata               = $page_info[5];
1665                 $pagesettings           = $page_info[6];
1666                 $pagelastmodified       = $page_info[7];
1667
1668                 # Put the values into the page hash.
1669
1670                 %database_page = (
1671                         "PageFilename"          => $pagefilename,
1672                         "PageName"              => $pagename,
1673                         "PageDescription"       => $pagedescription,
1674                         "PageSection"           => $pagesection,
1675                         "PageTemplate"          => $pagetemplate,
1676                         "PageContent"           => $pagedata,
1677                         "PageSettings"          => $pagesettings,
1678                         "PageLastModified"      => $pagelastmodified,
1679                 );
1680
1681                 # The page information is found.
1682
1683                 $page_found = 1;
1684
1685         }
1686
1687         # Check if the page really does exist.
1688
1689         if (!$page_found){
1690
1691                 $error = "PageDoesNotExist";
1692                 return;
1693
1694         }
1695
1696         # Check if the page with the filename given already exists in
1697         # the database the page is being moved to.
1698
1699         $page_found = 0;
1700         @page_info = ();
1701
1702         $second_statement_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 );
1703         $second_statement_handle->execute();
1704
1705         while (@page_info = $second_statement_handle->fetchrow_array()){
1706
1707                 $page_found = 1;
1708
1709         }
1710
1711         # Check if the page really does exist.
1712
1713         if ($page_found){
1714
1715                 $error = "PageAlreadyExists";
1716                 return;
1717
1718         }
1719
1720         # Add the page to the new database.
1721
1722         $second_statement_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1723                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1724                 \'' . $class->convert($database_page{"PageName"}) . '\',
1725                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1726                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1727                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1728                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1729                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1730                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1731         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1732         $second_statement_handle->execute();
1733
1734         # Delete the page from the old database.
1735
1736         $statement_handle = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $class->convert($database_page{"PageFilename"}) . '\'') or ( $error = "OldDatabaseError", $errorext = $database_handle->errstr, return );
1737         $statement_handle->execute();
1738
1739 }
1740
1741 sub copypage{
1742 #################################################################################
1743 # copypage: Copies a page from the old database to the new database.            #
1744 #                                                                               #
1745 # Usage:                                                                        #
1746 #                                                                               #
1747 # $dbmodule->copypage(options);                                                 #
1748 #                                                                               #
1749 # options       Specifies the following options in any order.                   #
1750 #                                                                               #
1751 # PageFilename  Specifies the page with the filename to copy.                   #
1752 #################################################################################
1753
1754         $error = "";
1755         $errorext = "";
1756
1757         # Get the values passed to the subroutine.
1758
1759         my $class = shift;
1760         my ($passedoptions) = @_;
1761
1762         my (%database_page, $database_page);
1763         my ($pagefilename, $pagename, $pagedescription, $pagesection, $pagetemplate, $pagedata, $pagesettings, $pagelastmodified);
1764         my @page_info;
1765         my $page_found = 0;
1766
1767         # Get the data that was passed to the subroutine.
1768
1769         my $page_filename = $passedoptions->{"PageFilename"};
1770
1771         # Check if the page with the filename given exists.
1772
1773         $statement_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 );
1774         $statement_handle->execute();
1775
1776         # Check if the page really does exist.
1777
1778         while (@page_info = $statement_handle->fetchrow_array()){
1779
1780                 # Get the values from the array.
1781
1782                 $pagefilename           = $page_info[0];
1783                 $pagename               = $page_info[1];
1784                 $pagedescription        = $page_info[2];
1785                 $pagesection            = $page_info[3];
1786                 $pagetemplate           = $page_info[4];
1787                 $pagedata               = $page_info[5];
1788                 $pagesettings           = $page_info[6];
1789                 $pagelastmodified       = $page_info[7];
1790
1791                 # Put the values into the page hash.
1792
1793                 %database_page = (
1794                         "PageFilename"          => $pagefilename,
1795                         "PageName"              => $pagename,
1796                         "PageDescription"       => $pagedescription,
1797                         "PageSection"           => $pagesection,
1798                         "PageTemplate"          => $pagetemplate,
1799                         "PageContent"           => $pagedata,
1800                         "PageSettings"          => $pagesettings,
1801                         "PageLastModified"      => $pagelastmodified,
1802                 );
1803
1804                 # The page information is found.
1805
1806                 $page_found = 1;
1807
1808         }
1809
1810         # Check if the page really does exist.
1811
1812         if (!$page_found){
1813
1814                 $error = "PageDoesNotExist";
1815                 return;
1816
1817         }
1818
1819         # Check if the page with the filename given already exists in
1820         # the database the page is being moved to.
1821
1822         $page_found = 0;
1823         @page_info = ();
1824
1825         $second_statement_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 );
1826         $second_statement_handle->execute();
1827
1828         while (@page_info = $second_statement_handle->fetchrow_array()){
1829
1830                 $page_found = 1;
1831
1832         }
1833
1834         # Check if the page really does exist.
1835
1836         if ($page_found){
1837
1838                 $error = "PageAlreadyExists";
1839                 return;
1840
1841         }
1842
1843         # Add the page to the new database.
1844
1845         $second_statement_handle = $second_database_handle->prepare('INSERT INTO kiriwrite_database_pages (filename, pagename, pagedescription, pagesection, pagetemplate, pagedata, pagesettings, lastmodified) VALUES (
1846                 \'' . $class->convert($database_page{"PageFilename"}) . '\',
1847                 \'' . $class->convert($database_page{"PageName"}) . '\',
1848                 \'' . $class->convert($database_page{"PageDescription"}) . '\',
1849                 \'' . $class->convert($database_page{"PageSection"}) . '\',
1850                 \'' . $class->convert($database_page{"PageTemplate"}) . '\',
1851                 \'' . $class->convert($database_page{"PageContent"}) . '\',
1852                 \'' . $class->convert($database_page{"PageSettings"}) . '\',
1853                 \'' . $class->convert($database_page{"PageLastModified"}) . '\'
1854         )') or ( $error = "NewDatabaseError", $errorext = $second_database_handle->errstr, return );
1855         $second_statement_handle->execute();
1856
1857 }
1858
1859 #################################################################################
1860 # Filter subroutines.                                                           #
1861 #################################################################################
1862
1863 sub connectfilter{
1864 #################################################################################
1865 # connectfilter: Connect to the filter database.                                #
1866 #                                                                               #
1867 # Usage:                                                                        #
1868 #                                                                               #
1869 # $dbmodule->connectfilter(missingignore);                                      #
1870 #                                                                               #
1871 # missingignore Ignore error about database being missing.                      #
1872 #################################################################################
1873
1874         $error = "";
1875         $errorext = "";
1876
1877         my $class = shift;
1878         my $ignoremissing = shift;
1879
1880         # Check if the template database exists.
1881
1882         my $filterdatabase_exists = main::kiriwrite_fileexists("filters.db.sqlite");
1883
1884         if ($filterdatabase_exists eq 1){
1885
1886                 $filterdb_exists = 0;
1887
1888                 if (!$ignoremissing){
1889
1890                         $error = "FilterDatabaseDoesNotExist";
1891                         return;
1892
1893                 }
1894
1895         }
1896
1897         # Check if the permission settings for the template database are valid.
1898
1899         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 0);
1900
1901         if ($filterdb_permissions eq 1){
1902
1903                 # The template database has invalid permissions set
1904                 # so return an error value.
1905
1906                 if (!$ignoremissing){
1907
1908                         $error = "FilterDatabaseInvalidPermissionsSet";
1909                         return;
1910
1911                 }
1912
1913         }
1914
1915         # Connect to the template database.
1916
1917         $filterdb_database_handle = DBI->connect("dbi:SQLite:dbname=filters.db.sqlite");
1918         $filterdb_database_handle->{unicode} = 1;
1919         $filterdb_loaded = 1;
1920
1921 }
1922
1923 sub disconnectfilter{
1924 #################################################################################
1925 # disconnectfilter: Disconnect from the filter database.                        #
1926 #                                                                               #
1927 # Usage:                                                                        #
1928 #                                                                               #
1929 # $dbmodule->disconnectfilter();                                                #
1930 #################################################################################
1931
1932         # Disconnect the template database.
1933
1934         if ($filterdb_loaded eq 1){
1935
1936                 undef $filterdb_statement_handle;
1937                 $filterdb_database_handle->disconnect();
1938
1939         }
1940
1941 }
1942
1943 sub getfiltercount{
1944 #################################################################################
1945 # getfiltercount: Gets the count of filters in the filters database.            #
1946 #                                                                               #
1947 # Usage:                                                                        #
1948 #                                                                               #
1949 # $dbmodule->getfiltercount();                                                  #
1950 #################################################################################
1951
1952         $error = "";
1953         $errorext = "";
1954
1955         my $class       = shift;
1956
1957         $filterdb_statement_handle      = $filterdb_database_handle->prepare('SELECT COUNT(*) FROM kiriwrite_filters') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return);
1958         $filterdb_statement_handle->execute();
1959
1960         my $count = $filterdb_statement_handle->fetchrow_array();
1961
1962         return $count;
1963
1964 }
1965
1966 sub getfilterlist{
1967 #################################################################################
1968 # getfilterlist: Gets the list of filters in the filter database.               #
1969 #                                                                               #
1970 # Usage:                                                                        #
1971 #                                                                               #
1972 # $dbmodule->getfilterlist(options);                                            #
1973 #                                                                               #
1974 # StartFrom     Specifies where the list of filters should start from.          #
1975 # Limit         Specifies the amount of the filters to get.                     #
1976 #################################################################################
1977
1978         $error = "";
1979         $errorext = "";
1980
1981         my $class               = shift;
1982         my ($passedoptions)     = shift;
1983
1984         my @filter_list;
1985         my @filter_data;
1986
1987         my $start_from  = $passedoptions->{"StartFrom"};
1988         my $limit       = $passedoptions->{"Limit"};
1989
1990         if (defined($start_from)){
1991
1992                 if (!$limit){
1993
1994                         $limit = 0;
1995
1996                 }
1997
1998                 $filterdb_statement_handle      = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY priority ASC LIMIT ' . $start_from . ',' . $limit) or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
1999                 $filterdb_statement_handle->execute();
2000
2001         } else {
2002
2003                 $filterdb_statement_handle      = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY priority ASC') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2004                 $filterdb_statement_handle->execute();
2005
2006         }
2007
2008         # Get the list of filters available.
2009
2010         while (@filter_data = $filterdb_statement_handle->fetchrow_array()){
2011
2012                 # Add the filter to the list of available filters.
2013
2014                 push(@filter_list, $filter_data[0]);
2015
2016         }
2017
2018         undef $filterdb_statement_handle;
2019         return @filter_list;
2020
2021 }
2022
2023 sub getfilterinfo{
2024 #################################################################################
2025 # getfilterinfo: Gets information about the filter.                             #
2026 #                                                                               #
2027 # Usage:                                                                        #
2028 #                                                                               #
2029 # $dbmodule->getfilterinfo(options);                                            #
2030 #                                                                               #
2031 # options       Specifies the following options in any order.                   #
2032 #                                                                               #
2033 # FilterID      Specifies the filter ID number to get information from.         #
2034 # Reduced       Specifies if the reduced version of the filter information      #
2035 #               should be retrieved.                                            #
2036 #################################################################################
2037
2038         $error = "";
2039         $errorext = "";
2040
2041         # Get the values passed to the subroutine.
2042
2043         my $class               = shift;
2044         my ($passedoptions)     = @_;
2045
2046         my %filter_info;
2047         my $filter_exists       = 0;
2048         my @filter_data;
2049
2050         # Get the values that are in the hash.
2051
2052         my $filter_id           = $passedoptions->{"FilterID"};
2053         my $reduced             = $passedoptions->{"Reduced"};
2054
2055         if ($reduced && $reduced eq 1){
2056
2057                 $filterdb_statement_handle = $filterdb_database_handle->prepare('SELECT id, priority, findsetting, replacesetting FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2058                 $filterdb_statement_handle->execute();
2059
2060         } else {
2061
2062                 $filterdb_statement_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 );
2063                 $filterdb_statement_handle->execute();
2064
2065         }
2066
2067         # Get the filter information.
2068
2069         while (@filter_data = $filterdb_statement_handle->fetchrow_array()){
2070
2071                 $filter_info{"FilterID"}        = $filter_data[0];
2072                 $filter_info{"FilterPriority"}  = $filter_data[1];
2073                 $filter_info{"FilterFind"}      = $filter_data[2];
2074                 $filter_info{"FilterReplace"}   = $filter_data[3];
2075                 $filter_info{"FilterNotes"}     = $filter_data[4];
2076
2077                 $filter_exists = 1;
2078
2079         }
2080
2081         # Check if the filter exists.
2082
2083         if (!$filter_exists){
2084
2085                 # The filter does not exist so return
2086                 # an error value.
2087
2088                 $error = "FilterDoesNotExist";
2089                 return;
2090
2091         }
2092
2093         # Return the filter information.
2094
2095         undef $filterdb_statement_handle;
2096         return %filter_info;
2097
2098 }
2099
2100 sub addfilter{
2101 #################################################################################
2102 # addfilter: Adds a filter to the filter database.                              #
2103 #                                                                               #
2104 # Usage:                                                                        #
2105 #                                                                               #
2106 # $dbmodule->addfilter(options);                                                #
2107 #                                                                               #
2108 # options       Specifies the following options in any order.                   #
2109 #                                                                               #
2110 # FindFilter    Specifies the find filter to add.                               #
2111 # ReplaceFilter Specifies the replace filter to add.                            #
2112 # Priority      Specifies the filter priority to use.                           #
2113 # Notes         Specifies the notes to use.                                     #
2114 #################################################################################
2115
2116         $error = "";
2117         $errorext = "";
2118
2119         # Get the values passed to the subroutine.
2120
2121         my $class = shift;
2122         my ($passedoptions) = @_;
2123
2124         # Define some variables for later.
2125
2126         my @database_filters;
2127         my @filterid_list;
2128         my @filterid_check;
2129         my $nofiltertable = 0;
2130         my $filter_found = 0;
2131         my $filter_count = 0;
2132         my $filter_id;
2133         my $new_id;
2134
2135         # Get the values from the hash.
2136
2137         my $filter_find         = $passedoptions->{"FindFilter"};
2138         my $filter_replace      = $passedoptions->{"ReplaceFilter"};
2139         my $filter_priority     = $passedoptions->{"Priority"};
2140         my $filter_notes        = $passedoptions->{"Notes"};
2141
2142         # Check if the filter database permissions are valid.
2143
2144         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
2145         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
2146
2147         if ($filterdb_permissions eq 1){
2148
2149                 if ($filterdb_exists eq 0){
2150                         $error = "FilterDatabaseInvalidPermissionsSet";
2151                         return;
2152                 }
2153
2154         }
2155
2156         # Check if certain values are undefined and if they
2157         # are then set them blank.
2158
2159         if (!$filter_find){
2160
2161                 $filter_find = "";
2162
2163         }
2164
2165         if (!$filter_replace){
2166
2167                 $filter_replace = "";
2168
2169         }
2170
2171         if (!$filter_priority){
2172
2173                 $filter_priority = 1;
2174
2175         }
2176
2177         if (!$filter_notes){
2178
2179                 $filter_notes = "";
2180
2181         }
2182
2183         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2184
2185         if ($directory_permissions eq 1 && $filterdb_exists){
2186
2187                 # The template database cannot be created because of invalid directory
2188                 # permissions so return an error value.
2189
2190                 $error = "FilterDatabaseFileUncreateable";
2191                 return;
2192
2193         }
2194
2195         # Check if the filter table exists.
2196
2197         $filterdb_statement_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY id ASC') or ( $nofiltertable = 1 );
2198
2199         # Check if there is really no filter table.
2200
2201         if ($nofiltertable){
2202
2203                 # Create the filter database table.
2204
2205                 $filterdb_statement_handle = $filterdb_database_handle->prepare('CREATE TABLE kiriwrite_filters (
2206                         id int(7) primary key,
2207                         priority int(5),
2208                         findsetting varchar(1024),
2209                         replacesetting varchar(1024),
2210                         notes text
2211                 )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2212                 $filterdb_statement_handle->execute();
2213
2214         }
2215
2216         # Find the lowest filter identification number available.
2217
2218         $filterdb_statement_handle = $filterdb_database_handle->prepare('SELECT id FROM kiriwrite_filters ORDER BY id ASC') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2219         $filterdb_statement_handle->execute();
2220
2221         while (@database_filters = $filterdb_statement_handle->fetchrow_array()){
2222
2223                 $filter_id      = $database_filters[0];
2224
2225                 # Add the filter identification to the list of filter IDs.
2226
2227                 push(@filterid_list, $filter_id);
2228
2229         }
2230
2231         $filter_id = "";
2232
2233         # Process each filter looking for a blank available filter.
2234
2235         foreach $filter_id (@filterid_list){
2236
2237                 # Check the next filter ID to see if it's blank.
2238
2239                 $new_id = $filter_id + 1;
2240
2241                 $filterdb_statement_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 );
2242                 $filterdb_statement_handle->execute();
2243
2244                 # Get the filter identification number.
2245
2246                 while (@filterid_check = $filterdb_statement_handle->fetchrow_array()){
2247
2248                         $filter_found = 1;
2249
2250                 }
2251
2252                 # Check if a filter was found.
2253
2254                 if (!$filter_found){
2255
2256                         # No filter was found using this ID so exit the loop.
2257
2258                         last;
2259
2260                 }
2261
2262                 # Increment the filter count and reset the filter found value.
2263
2264                 $filter_count++;
2265                 $filter_found = 0;
2266                 $new_id = 0;
2267
2268         }
2269
2270         # Check if there were any filters in the filter database.
2271
2272         if (!$filter_count && !$new_id){
2273
2274                 # There were no filters in the filter database so set
2275                 # the new filter identification value to 1.
2276
2277                 $new_id = 1;
2278
2279         }
2280
2281         # Add the filter to the filter database.
2282
2283         $filterdb_statement_handle = $filterdb_database_handle->prepare('INSERT INTO kiriwrite_filters (id, priority, findsetting, replacesetting, notes) VALUES (
2284                 \'' . $class->convert($new_id) . '\',
2285                 \'' . $class->convert($filter_priority) . '\',
2286                 \'' . $class->convert($filter_find) . '\',
2287                 \'' . $class->convert($filter_replace) .'\',
2288                 \'' . $class->convert($filter_notes) . '\'
2289         )') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2290         $filterdb_statement_handle->execute();
2291
2292 }
2293
2294 sub editfilter{
2295 #################################################################################
2296 # editfilter: Edits a filter in the filter database.                            #
2297 #                                                                               #
2298 # Usage:                                                                        #
2299 #                                                                               #
2300 # $dbmodule->editfilter(options);                                               #
2301 #                                                                               #
2302 # options       Specifies the following options in any order.                   #
2303 #                                                                               #
2304 # FilterID              Specifies the filter to edit.                           #
2305 # NewFindFilter         Specifies the new find filter setting.                  #
2306 # NewReplaceFilter      Specifies the new replace filter setting.               #
2307 # NewFilterPriority     Specifies the new filter priority setting.              #
2308 # NewFilterNotes        Specifies the new notes for the filter.                 #
2309 #################################################################################
2310
2311         $error = "";
2312         $errorext = "";
2313
2314         # Get the values passed to the subroutine.
2315
2316         my $class = shift;
2317         my ($passedoptions) = @_;
2318
2319         my @filter_data;
2320         my $filter_exists = 1;
2321         my $blankfile = 0;
2322
2323         # Get the values from the hash.
2324
2325         my $filter_id           = $passedoptions->{"FilterID"};
2326         my $filter_newfind      = $passedoptions->{"NewFindFilter"};
2327         my $filter_newreplace   = $passedoptions->{"NewReplaceFilter"};
2328         my $filter_newpriority  = $passedoptions->{"NewFilterPriority"};
2329         my $filter_newnotes     = $passedoptions->{"NewFilterNotes"};
2330
2331         # Check if the filter database permissions are valid.
2332
2333         my $filterdb_exists = main::kiriwrite_fileexists("filters.db.sqlite", 1, 1);
2334         my $filterdb_permissions = main::kiriwrite_filepermissions("filters.db.sqlite", 1, 1);
2335
2336         if ($filterdb_permissions eq 1){
2337
2338                 if ($filterdb_exists eq 0){
2339                         $error = "FilterDatabaseInvalidPermissionsSet";
2340                         return;
2341                 }
2342
2343         }
2344
2345         # Check if the filter exists before editing it.
2346
2347         $filterdb_statement_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 );
2348         $filterdb_statement_handle->execute();
2349
2350         # Check if the filter exists.
2351
2352         while (@filter_data = $filterdb_statement_handle->fetchrow_array()){
2353
2354                 $filter_exists = 1;
2355
2356         }
2357
2358         # Check if the filter really does exist.
2359
2360         if (!$filter_exists){
2361
2362                 # The filter does not exist so return
2363                 # an error value.
2364
2365                 $error = "FilterDoesNotExist";
2366                 return;
2367
2368         }
2369
2370         # Edit the selected filter.
2371
2372         $filterdb_statement_handle = $filterdb_database_handle->prepare('UPDATE kiriwrite_filters SET
2373                 findsetting = \'' . $class->convert($filter_newfind) . '\',
2374                 replacesetting = \'' . $class->convert($filter_newreplace) . '\',
2375                 priority = \'' . $class->convert($filter_newpriority) . '\',
2376                 notes = \'' . $class->convert($filter_newnotes) . '\'
2377         WHERE id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2378         $filterdb_statement_handle->execute();
2379
2380         undef $filterdb_statement_handle;
2381         return;
2382
2383 }
2384
2385 sub deletefilter{
2386 #################################################################################
2387 # deletefilter: Deletes a filter from the filter database.                      #
2388 #                                                                               #
2389 # Usage:                                                                        #
2390 #                                                                               #
2391 # $dbmodule->deletefilter(options);                                             #
2392 #                                                                               #
2393 # options       Specifies the following options in any order.                   #
2394 #                                                                               #
2395 # FilterID      Specifies the filter to delete from the filter database.        #
2396 #################################################################################
2397
2398         $error = "";
2399         $errorext = "";
2400
2401         # Get the values passed to the subroutine.
2402
2403         my $class = shift;
2404         my ($passedoptions) = @_;
2405
2406         my $filter_exists = 0;
2407         my @filter_data;
2408
2409         # Get the values from the hash.
2410
2411         my $filter_id           = $passedoptions->{"FilterID"};
2412
2413         # Check if the filter exists before deleting.
2414
2415         $filterdb_statement_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 );
2416         $filterdb_statement_handle->execute();
2417
2418         while (@filter_data = $filterdb_statement_handle->fetchrow_array()){
2419
2420                 $filter_exists = 1;
2421
2422         }
2423
2424         # Check to see if the filter really does exist.
2425
2426         if (!$filter_exists){
2427
2428                 $error = "FilterDoesNotExist";
2429                 return;
2430
2431         }
2432
2433         # Delete the filter from the filter database.
2434
2435         $filterdb_statement_handle = $filterdb_database_handle->prepare('DELETE FROM kiriwrite_filters where id = \'' . $class->convert($filter_id) . '\'') or ( $error = "FilterDatabaseError", $errorext = $filterdb_database_handle->errstr, return );
2436         $filterdb_statement_handle->execute();
2437
2438         undef $filterdb_statement_handle;
2439
2440 }
2441
2442 #################################################################################
2443 # Template subroutines.                                                         #
2444 #################################################################################
2445
2446 sub connecttemplate{
2447 #################################################################################
2448 # connecttemplate: Connect to the template database.                            #
2449 #                                                                               #
2450 # Usage:                                                                        #
2451 #                                                                               #
2452 # $dbmodule->connecttemplate(missingignore);                                    #
2453 #                                                                               #
2454 # missingignore Ignore errror about database being missing.                     #
2455 #################################################################################
2456
2457         $error = "";
2458         $errorext = "";
2459
2460         my $class = shift;
2461         my $ignoremissing = shift;
2462
2463         # Check if the template database exists.
2464
2465         my $templatedatabase_exists = main::kiriwrite_fileexists("templates.db.sqlite");
2466
2467         if ($templatedatabase_exists eq 1){
2468
2469                 $templatedb_exists = 0;
2470
2471                 if (!$ignoremissing){
2472
2473                         $error = "TemplateDatabaseDoesNotExist";
2474                         return;
2475
2476                 }
2477
2478         }
2479
2480         # Check if the permission settings for the template database are valid.
2481
2482         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 0);
2483
2484         if ($templatedb_permissions eq 1){
2485
2486                 # The template database has invalid permissions set
2487                 # so return an error value.
2488
2489                 if (!$ignoremissing){
2490
2491                         $error = "TemplateDatabaseInvalidPermissionsSet";
2492                         return;
2493
2494                 }
2495
2496         }
2497
2498         # Connect to the template database.
2499
2500         $template_database_handle = DBI->connect("dbi:SQLite:dbname=templates.db.sqlite");
2501         $template_database_handle->{unicode} = 1;
2502         $templatedb_loaded = 1;
2503
2504 }
2505
2506 sub disconnecttemplate{
2507 #################################################################################
2508 # disconnecttemplate: Disconnect from the template database.                    #
2509 #                                                                               #
2510 # Usage:                                                                        #
2511 #                                                                               #
2512 # $dbmodule->disconnecttemplate();                                              #
2513 #################################################################################
2514
2515         # Disconnect the template database.
2516
2517         if ($templatedb_loaded eq 1){
2518
2519                 undef $template_statement_handle;
2520                 $template_database_handle->disconnect();
2521
2522         }
2523
2524 }
2525
2526 sub gettemplatecount{
2527 #################################################################################
2528 # gettemplatecount: Gets the count of templates in the template database.       #
2529 #                                                                               #
2530 # Usage:                                                                        #
2531 #                                                                               #
2532 # $dbmodule->gettemplatecount();                                                #
2533 #################################################################################
2534
2535         $error = "";
2536         $errorext = "";
2537
2538         my $class       = shift;
2539
2540         $template_statement_handle      = $template_database_handle->prepare('SELECT COUNT(*) FROM kiriwrite_templates') or ( $error = "FilterDatabaseError", $errorext = $template_database_handle->errstr, return);
2541         $template_statement_handle->execute();
2542
2543         my $count = $template_statement_handle->fetchrow_array();
2544
2545         return $count;
2546
2547 }
2548
2549 sub gettemplatelist{
2550 #################################################################################
2551 # gettemplatelist: Gets the list of templates.                                  #
2552 #                                                                               #
2553 # Usage:                                                                        #
2554 #                                                                               #
2555 # $dbmodule->gettemplatelist(options);                                          #
2556 #                                                                               #
2557 # options       Specifies the following options as a hash (in any order).       #
2558 #                                                                               #
2559 # StartFrom     Specifies where the list of templates will start from.          #
2560 # Limit         Specifies how many templates should be retrieved.               #
2561 #################################################################################
2562
2563         $error = "";
2564         $errorext = "";
2565
2566         my $class               = shift;
2567         my ($passedoptions)     = @_;
2568
2569         my $start_from          = $passedoptions->{"StartFrom"};
2570         my $limit               = $passedoptions->{"Limit"};
2571
2572         if (defined($start_from)){
2573
2574                 if (!$limit){
2575
2576                         $limit = 0;
2577
2578                 }
2579
2580                 $template_statement_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates ORDER BY filename ASC LIMIT ' . $start_from . ',' .  $limit ) or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2581                 $template_statement_handle->execute();
2582
2583         } else {
2584
2585                 $template_statement_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates ORDER BY filename ASC') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2586                 $template_statement_handle->execute();
2587
2588         }
2589
2590         my @database_template;
2591         my @templates_list;
2592         my $template_filename;
2593
2594         while (@database_template = $template_statement_handle->fetchrow_array()){
2595
2596                 # Get certain values from the array.
2597
2598                 $template_filename      = $database_template[0];
2599
2600                 # Add the template to the list of templates.
2601
2602                 push(@templates_list, $template_filename);
2603
2604         }
2605
2606         return @templates_list;
2607
2608 }
2609
2610 sub gettemplateinfo{
2611 #################################################################################
2612 # gettemplateinfo: Get information on a template.                               #
2613 #                                                                               #
2614 # Usage:                                                                        #
2615 #                                                                               #
2616 # $dbmodule->gettemplateinfo(options);                                          #
2617 #                                                                               #
2618 # options       Specifies the following options in any order.                   #
2619 #                                                                               #
2620 # TemplateFilename      Specifies the template filename to use.                 #
2621 # Reduced               Specifies a reduced version of template information to  #
2622 #                       get.                                                    #
2623 #################################################################################
2624
2625         $error = "";
2626         $errorext = "";
2627
2628         # Get the data passed to the subroutine.
2629
2630         my $class = shift;
2631         my ($passedoptions) = @_;
2632
2633         my %page_info;
2634         my @template_data;
2635
2636         my $template_filename;
2637         my $template_name;
2638         my $template_description;
2639         my $template_datemodified;
2640         my $template_layout;
2641
2642         my $template_found = 0;
2643
2644         my $filename    = $passedoptions->{"TemplateFilename"};
2645         my $reduced     = $passedoptions->{"Reduced"};
2646
2647         if ($reduced && $reduced eq 1){
2648
2649                 $template_statement_handle = $template_database_handle->prepare('SELECT filename, templatename, templatedescription, datemodified FROM kiriwrite_templates WHERE filename = \'' . $class->convert($filename) . '\'') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2650                 $template_statement_handle->execute();
2651
2652         } else {
2653
2654                 $template_statement_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 );
2655                 $template_statement_handle->execute();
2656
2657         }
2658
2659         while (@template_data = $template_statement_handle->fetchrow_array()){
2660
2661                 # Get certain values from the array.
2662
2663                 $template_filename      = $template_data[0];
2664                 $template_name          = $template_data[1];
2665                 $template_description   = $template_data[2];
2666                 $template_layout        = $template_data[3];
2667                 $template_datemodified  = $template_data[4];
2668
2669                 # Process them into the hash.
2670
2671                 %page_info = (
2672                         "TemplateFilename" => $template_filename,
2673                         "TemplateName" => $template_name,
2674                         "TemplateDescription" => $template_description,
2675                         "TemplateLayout" => $template_layout,
2676                         "TemplateLastModified" => $template_datemodified
2677                 );
2678
2679                 $template_found = 1;
2680
2681         }
2682
2683         if ($template_found eq 0){
2684
2685                 # The template was not found in the template database so
2686                 # write an error value.
2687
2688                 $error = "TemplateDoesNotExist";
2689                 return;
2690
2691         }
2692
2693         return %page_info;
2694
2695 }
2696
2697 sub addtemplate{
2698 #################################################################################
2699 # addtemplate: Adds a template to the template database.                        #
2700 #                                                                               #
2701 # Usage:                                                                        #
2702 #                                                                               #
2703 # $dbmodule->addtemplate();                                                     #
2704 #                                                                               #
2705 # options       Specifies the following options in any order.                   #
2706 #                                                                               #
2707 # TemplateFilename      Specifies the new template filename.                    #
2708 # TemplateName          Specifies the new template name.                        #
2709 # TemplateDescription   Specifies the new template description.                 #
2710 # TemplateLayout        Specifies the new template layout.                      #
2711 #################################################################################
2712
2713         $error = "";
2714         $errorext = "";
2715
2716         # Get the data passed to the subroutine.
2717
2718         my $class = shift;
2719         my ($passedoptions) = @_;
2720
2721         my @page_exists;
2722         my $notemplatetable;
2723         my $blankfile = 0;
2724
2725         my $template_filename           = $passedoptions->{"TemplateFilename"};
2726         my $template_name               = $passedoptions->{"TemplateName"};
2727         my $template_description        = $passedoptions->{"TemplateDescription"};
2728         my $template_layout             = $passedoptions->{"TemplateLayout"};
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 already exists before adding.
2745
2746         if ($templatedb_exists eq 0){
2747
2748                 $template_statement_handle = $template_database_handle->prepare('SELECT filename FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\' LIMIT 1') or ($blankfile = 1);
2749
2750                 if ($blankfile eq 0){
2751
2752                         $template_statement_handle->execute();
2753
2754                         while (@page_exists = $template_statement_handle->fetchrow_array()){
2755
2756                                 $error = "TemplatePageExists";
2757                                 return;
2758
2759                         }
2760
2761                 }
2762
2763         }
2764
2765         # Get the current date.
2766
2767         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2768
2769         my $template_date = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2770
2771         # Check if certain values are undefined and if they
2772         # are then set them blank.
2773
2774         if (!$template_name){
2775
2776                 $template_name = "";
2777
2778         }
2779
2780         if (!$template_description){
2781
2782                 $template_description = "";
2783
2784         }
2785
2786         if (!$template_layout){
2787
2788                 $template_layout = "";
2789
2790         }
2791
2792         my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2793
2794         if ($directory_permissions eq 1 && $templatedb_exists){
2795
2796                 # The template database cannot be created because of invalid directory
2797                 # permissions so return an error value.
2798
2799                 $error = "TemplateDatabaseUncreateable";
2800                 return;
2801
2802         }
2803
2804         # Check to see if a template can be added.
2805
2806         $template_statement_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2807                                 \'' . $class->convert($template_filename) . '\',
2808                                 \'' . $class->convert($template_name) . '\',
2809                                 \'' . $class->convert($template_description) . '\',
2810                                 \'' . $class->convert($template_layout) . '\',
2811                                 \'' . $class->convert($template_date) . '\'
2812         )') or ( $notemplatetable = 1 );
2813
2814         if (!$notemplatetable){
2815
2816                 $template_statement_handle->execute();
2817
2818         }
2819
2820         # Check to see if there is no template table and attempt to create one.
2821
2822         if ($notemplatetable){
2823
2824                 # Create a template table.
2825
2826                 my $directory_permissions = main::kiriwrite_filepermissions(".", 1, 1, 0);
2827
2828                 if ($directory_permissions eq 1){
2829
2830                         # The template database cannot be created because of invalid directory
2831                         # permissions so return an error.
2832
2833                         $error = "TemplateDatabaseFileUncreateable";
2834                         return;
2835
2836                 }
2837
2838                 $template_statement_handle = $template_database_handle->prepare('create table kiriwrite_templates(
2839                         filename varchar(256) primary key,
2840                         templatename varchar(512),
2841                         templatedescription varchar(512),
2842                         templatelayout text,
2843                         datemodified datetime
2844                 );') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2845                 $template_statement_handle->execute();
2846
2847                 $template_statement_handle = $template_database_handle->prepare('INSERT INTO kiriwrite_templates (filename, templatename, templatedescription, templatelayout, datemodified) VALUES(
2848                                 \'' . $class->convert($template_filename) . '\',
2849                                 \'' . $class->convert($template_name) . '\',
2850                                 \'' . $class->convert($template_description) . '\',
2851                                 \'' . $class->convert($template_layout) . '\',
2852                                 \'' . $class->convert($template_date) . '\'
2853                 )') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2854                 $template_statement_handle->execute();
2855
2856         }
2857
2858 }
2859
2860 sub deletetemplate{
2861 #################################################################################
2862 # deletetemplate: Deletes a template from the template database.                #
2863 #                                                                               #
2864 # Usage:                                                                        #
2865 #                                                                               #
2866 # $dbmodule->deletetemplate(options);                                           #
2867 #                                                                               #
2868 # options       Specifies the following options in any order.                   #
2869 #                                                                               #
2870 # TemplateFilename      Specifies the template filename to delete.              #
2871 #################################################################################
2872
2873         $error = "";
2874         $errorext = "";
2875
2876         # Get the data passed to the subroutine.
2877
2878         my $class = shift;
2879         my ($passedoptions) = @_;
2880
2881         my @pagedata;
2882         my $template_filename = $passedoptions->{"TemplateFilename"};
2883         my $template_count = 0;
2884
2885         # Check if the template exists.
2886
2887         $template_statement_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 );
2888         $template_statement_handle->execute();
2889
2890         while (@pagedata = $template_statement_handle->fetchrow_array()){
2891
2892                 $template_count++;
2893
2894         }
2895
2896         if ($template_count eq 0){
2897
2898                 # No pages were returned so return an error value.
2899
2900                 $error = "TemplateDoesNotExist";
2901                 return;
2902
2903         }
2904
2905         # Delete the template from the template database.
2906
2907         $template_statement_handle = $template_database_handle->prepare('DELETE FROM kiriwrite_templates WHERE filename = \'' . $class->convert($template_filename) . '\'') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2908         $template_statement_handle->execute();
2909
2910 }
2911
2912 sub edittemplate{
2913 #################################################################################
2914 # editttemplate: Edits a Kiriwrite template.                                    #
2915 #                                                                               #
2916 # Usage:                                                                        #
2917 #                                                                               #
2918 # $dbmodule->edittemplate(options);                                             #
2919 #                                                                               #
2920 # options       Specifies the following options in any order.                   #
2921 #                                                                               #
2922 # TemplateFilename              Specifies the template filename to edit.        #
2923 # NewTemplateFilename           Specifies the new template filename.            #
2924 # NewTemplateName               Specifies the new template name.                #
2925 # NewTemplateDescription        Specifies the new template description.         #
2926 # NewTemplateLayout             Specifies the new template layout.              #
2927 #################################################################################
2928
2929         # Get the values passed.
2930
2931         my $class = shift;
2932         my ($passedoptions) = @_;
2933         my $template_found = 0;
2934         my @template_info;
2935
2936         # Process the values passed.
2937
2938         my $template_filename           = $passedoptions->{"TemplateFilename"};
2939         my $new_template_filename       = $passedoptions->{"NewTemplateFilename"};
2940         my $new_template_name           = $passedoptions->{"NewTemplateName"};
2941         my $new_template_description    = $passedoptions->{"NewTemplateDescription"};
2942         my $new_template_layout         = $passedoptions->{"NewTemplateLayout"};
2943
2944         # Check if the template database permissions are valid.
2945
2946         my $templatedb_exists = main::kiriwrite_fileexists("templates.db.sqlite", 1, 1);
2947         my $templatedb_permissions = main::kiriwrite_filepermissions("templates.db.sqlite", 1, 1);
2948
2949         if ($templatedb_permissions eq 1){
2950
2951                 if ($templatedb_exists eq 0){
2952                         $error = "TemplateDatabaseInvalidPermissionsSet";
2953                         return;
2954                 }
2955
2956         }
2957
2958         # Check if the template exists.
2959
2960         $template_statement_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 );
2961         $template_statement_handle->execute();
2962
2963         while (@template_info = $template_statement_handle->fetchrow_array()){
2964
2965                 $template_found = 1;
2966
2967         }
2968
2969         # Check to see if the template was found and set an error value if
2970         # it wasn't.
2971
2972         if ($template_found eq 0){
2973
2974                 $error = "TemplateDoesNotExist";
2975                 return;
2976
2977         }
2978
2979         # Get the date and time.
2980
2981         my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
2982         my $templatenewdate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
2983
2984         # Update the template information.
2985
2986         $template_statement_handle = $template_database_handle->prepare('UPDATE kiriwrite_templates SET
2987                 filename = \'' . $class->convert($new_template_filename) . '\',
2988                 templatename = \'' . $class->convert($new_template_name) . '\',
2989                 templatedescription = \'' . $class->convert($new_template_description) . '\',
2990                 templatelayout = \'' . $class->convert($new_template_layout) . '\',
2991                 datemodified = \'' . $class->convert($templatenewdate) . '\'
2992                 WHERE filename = \'' . $class->convert($template_filename) . '\'
2993         ') or ( $error = "TemplateDatabaseError", $errorext = $template_database_handle->errstr, return );
2994         $template_statement_handle->execute();
2995
2996 }
2997
2998 #################################################################################
2999 # General subroutines.                                                          #
3000 #################################################################################
3001
3002 sub connect{
3003 #################################################################################
3004 # connect: Connect to the server.                                               #
3005 #                                                                               #
3006 # Usage:                                                                        #
3007 #                                                                               #
3008 # $dbmodule->connect();                                                         #
3009 #################################################################################
3010
3011         # This function is not needed in this database module.
3012
3013 }
3014
3015 sub disconnect{
3016 #################################################################################
3017 # connect: Disconnect from the server.                                          #
3018 #                                                                               #
3019 # Usage:                                                                        #
3020 #                                                                               #
3021 # $dbmodule->disconnect();                                                      #
3022 #################################################################################
3023
3024         # This function is not needed in this database module.
3025
3026         undef $statement_handle;
3027
3028 }
3029
3030 1;