cgi-files/kiriwrite.cgi

   1 #!/usr/bin/perl -Tw
   2
   3 #################################################################################
   4 # Kiriwrite (kiriwrite.cgi)                                                     #
   5 # Main program script                                                           #
   6 #                                                                               #
   7 # Version: 0.0.2                                                                #
   8 #                                                                               #
   9 # Copyright (C) 2005-2007 Steve Brokenshire <sbrokenshire@xestia.co.uk>         #
  10 #                                                                               #
  11 # This program is free software; you can redistribute it and/or modify it under #
  12 # the terms of the GNU General Public License as published by the Free          #
  13 # Software Foundation; as version 2 of the License.                             #
  14 #                                                                               #
  15 # This program is distributed in the hope that it will be useful, but WITHOUT   #
  16 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS #
  17 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.#
  18 #                                                                               #
  19 # You should have received a copy of the GNU General Public License along with  #
  20 # this program; if not, write to the Free Software Foundation, Inc., 51         #
  21 # Franklin St, Fifth Floor, Boston, MA 02110-1301 USA                           #
  22 #################################################################################
  23
  24 use strict;                             # Throw errors if there's something wrong.
  25 use warnings;                           # Write warnings to the HTTP Server Log file.
  26
  27 use utf8;
  28 use CGI qw(:standard);
  29 use CGI::Carp('fatalsToBrowser');       # Output errors to the browser.
  30
  31 # Declare global variables for Kiriwrite settings and languages.
  32
  33 our($kiriwrite_config, %kiriwrite_config, $kiriwrite_lang, %kiriwrite_lang, $kiriwrite_version, %kiriwrite_version);
  34
  35 # Setup the version information for Kiriwrite.
  36
  37 %kiriwrite_version = (
  38         "major"         => 0,
  39         "minor"         => 0,
  40         "revision"      => 2
  41 );
  42
  43 #################################################################################
  44 # Begin listing the functions needed.                                           #
  45 #################################################################################
  46
  47 #sub AUTOLOAD{
  48 #################################################################################
  49 # AUTOLOAD: Catch-all for subroutines that do not exist.                        #
  50 #################################################################################
  51
  52         # A subroutine given does not exist so return an error.
  53
  54 #       kiriwrite_error("internalerror");
  55
  56 #}
  57
  58 sub kiriwrite_page_add{
  59 #################################################################################
  60 # kiriwrite_page_add: Adds a page to a database                                 #
  61 #                                                                               #
  62 # Usage:                                                                        #
  63 #                                                                               #
  64 # kiriwrite_page_add(database, pagefilename, title, description, section,       #
  65 #                       template, settings, info, confirm);                     #
  66 #                                                                               #
  67 # database      Specifies the database name.                                    #
  68 # pagefilename  Specifies the page filename.                                    #
  69 # title         Specifies the page title to be used.                            #
  70 # description   Specifies the short description of the page.                    #
  71 # section       Specifies the section assigned to the page.                     #
  72 # template      Specifies the template to use.                                  #
  73 # settings      Specifies the settings to be used on the page.                  #
  74 # data          Specifies the data which consists the page.                     #
  75 # confirm       Confirms action to add an page.                                 #
  76 #################################################################################
  77
  78         # Fetch the required variables that have been passed to the subroutine.
  79
  80         my ($pagedatabase, $pagefilename, $pagetitle, $pagedescription, $pagesection, $pagetemplate, $pagesettings, $pagefiledata, $confirm) = @_;
  81
  82         # Load the required Perl modules.
  83
  84         use DBI;
  85
  86         # Check if the action to add a new page has been confirmed (or not).
  87
  88         my $pagedata = "";
  89
  90         if (!$confirm){
  91
  92                 $confirm = 0;
  93
  94         }
  95
  96         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
  97
  98         # Check if the database filename is valid and return an error if
  99         # it isn't.
 100
 101         my $pagedatabase_filename_check = kiriwrite_variablecheck($pagedatabase, "filename", 0, 1);
 102
 103         if ($pagedatabase_filename_check eq 1){
 104
 105                 # The database filename is blank, so return an error.
 106
 107                 kiriwrite_error("blankdatabasepageadd");
 108
 109         } elsif ($pagedatabase_filename_check eq 2){
 110
 111                 # The database filename is invalid, so return an error.
 112
 113                 kiriwrite_error("databasefilenameinvalid");
 114
 115         }
 116
 117         # Check the length the database name and return an error if it's
 118         # too long.
 119
 120         my $pagedatabase_length_check   = kiriwrite_variablecheck($pagedatabase, "maxlength", 64, 1);
 121
 122         if ($pagedatabase_length_check eq 1){
 123
 124                 # The database name is too long, so return an error.
 125
 126                 kiriwrite_error("databasefilenametoolong");
 127
 128         }
 129
 130         if ($confirm eq "1"){
 131
 132                 # Check all the variables to see if they UTF8 valid.
 133
 134                 kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
 135                 kiriwrite_variablecheck($pagetitle, "utf8", 0, 0);
 136                 kiriwrite_variablecheck($pagedescription, "utf8", 0, 0);
 137                 kiriwrite_variablecheck($pagesection, "utf8", 0, 0);
 138                 kiriwrite_variablecheck($pagedatabase, "utf8", 0, 0);
 139                 kiriwrite_variablecheck($pagesettings, "utf8", 0, 0);
 140                 kiriwrite_variablecheck($pagetemplate, "utf8", 0, 0);
 141                 kiriwrite_variablecheck($pagefiledata, "utf8", 0, 0);
 142
 143                 # Convert the values into proper UTF8 values.
 144
 145                 $pagefilename           = kiriwrite_utf8convert($pagefilename);
 146                 $pagetitle              = kiriwrite_utf8convert($pagetitle);
 147                 $pagedescription        = kiriwrite_utf8convert($pagedescription);
 148                 $pagesection            = kiriwrite_utf8convert($pagesection);
 149                 $pagedatabase           = kiriwrite_utf8convert($pagedatabase);
 150                 $pagesettings           = kiriwrite_utf8convert($pagesettings);
 151                 $pagetemplate           = kiriwrite_utf8convert($pagetemplate);
 152                 $pagefiledata           = kiriwrite_utf8convert($pagefiledata);
 153
 154                 # Check all the variables (except for the page data, filename and settings
 155                 # will be checked more specifically later if needed) that were passed to
 156                 # the subroutine.
 157
 158                 my $pagefilename_maxlength_check                = kiriwrite_variablecheck($pagefilename, "maxlength", 256, 1);
 159                 my $pagetitle_maxlength_check                   = kiriwrite_variablecheck($pagetitle, "maxlength", 512, 1);
 160                 my $pagedescription_maxlength_check             = kiriwrite_variablecheck($pagedescription, "maxlength", 512, 1);
 161                 my $pagesection_maxlength_check                 = kiriwrite_variablecheck($pagesection, "maxlength", 256, 1);
 162                 my $pagedatabase_maxlength_check                = kiriwrite_variablecheck($pagedatabase, "maxlength", 64, 1);
 163                 my $pagesettings_maxlength_check                = kiriwrite_variablecheck($pagesettings, "maxlength", 1, 1);
 164                 my $pagetemplate_maxlength_check                = kiriwrite_variablecheck($pagetemplate, "maxlength", 64, 1);
 165
 166                 # Check if an value returned is something else other than 0.
 167
 168                 if ($pagefilename_maxlength_check eq 1){
 169
 170                         # The page filename given is too long, so return an error.
 171
 172                         kiriwrite_error("pagefilenametoolong");
 173
 174                 }
 175
 176                 if ($pagetitle_maxlength_check eq 1){
 177
 178                         # The page title given is too long, so return an error.
 179
 180                         kiriwrite_error("pagetitletoolong");
 181
 182                 }
 183
 184                 if ($pagedescription_maxlength_check eq 1){
 185
 186                         # The page description given is too long, so return an error.
 187
 188                         kiriwrite_error("pagedescriptiontoolong");
 189
 190                 }
 191
 192                 if ($pagesection_maxlength_check eq 1){
 193
 194                         # The page section given is too long, so return an error.
 195
 196                         kiriwrite_error("pagesectiontoolong");
 197
 198                 }
 199
 200                 if ($pagedatabase_maxlength_check eq 1){
 201
 202                         # The page database given is too long, so return an error.
 203
 204                         kiriwrite_error("pagedatabasefilenametoolong");
 205
 206                 }
 207
 208                 if ($pagesettings_maxlength_check eq 1){
 209
 210                         # The page settings given is too long, so return an error.
 211
 212                         kiriwrite_error("pagesettingstoolong");
 213
 214                 }
 215
 216                 if ($pagetemplate_maxlength_check eq 1){
 217
 218                         # The page template given is too long, so return an error.
 219
 220                         kiriwrite_error("pagetemplatefilenametoolong");
 221
 222                 }
 223
 224                 # The action to create a new page has been confirmed, so add the page to the
 225                 # selected database.
 226
 227                 if (!$pagefilename){
 228                         kiriwrite_error("pagefilenameblank");
 229                 }
 230
 231                 # Check the page filename and page settings.
 232
 233                 my $pagefilename_filename_check = kiriwrite_variablecheck($pagefilename, "page_filename", 0, 1);
 234                 my $pagesettings_setting_check  = kiriwrite_variablecheck($pagesettings, "pagesetting", 0, 1);
 235                 my $pagetemplate_filename_check = 0;
 236
 237                 if ($pagetemplate ne "!none"){
 238
 239                         # A template is being used so check the filename of the
 240                         # template.
 241
 242                         $pagetemplate_filename_check    = kiriwrite_variablecheck($pagetemplate, "page_filename", 0, 1);
 243
 244                 }
 245
 246                 if ($pagefilename_filename_check eq 1){
 247
 248                         # The page filename given is invalid, so return an error.
 249
 250                         kiriwrite_error("pagefilenameinvalid");
 251
 252                 }
 253
 254                 if ($pagesettings_setting_check eq 1){
 255
 256                         # The page settings given is invalid, so return an error.
 257
 258                         kiriwrite_error("pagesettingsinvalid");
 259
 260                 }
 261
 262                 if ($pagetemplate_filename_check eq 1){
 263
 264                         # The template filename given is invalid, so return an error
 265
 266                         kiriwrite_error("templatefilenameinvalid");
 267
 268                 }
 269
 270                 # Check the permissions of the page database.
 271
 272                 my $pagedatabase_exists         = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
 273                 my $pagedatabase_permissions    = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db', 1, 1, 0);
 274
 275                 if ($pagedatabase_exists eq 1){
 276
 277                         # The page database does not exist, so return an error.
 278
 279                         kiriwrite_error("databasefilemissing");
 280
 281                 }
 282
 283                 if ($pagedatabase_permissions eq 1){
 284
 285                         # The page database permissions are invalid, so return
 286                         # an error.
 287
 288                         kiriwrite_error("databaseinvalidpermissions");
 289
 290                 }
 291
 292                 # Load the SQLite database.
 293
 294                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
 295
 296                 # Check if the filename used already exists and return
 297                 # an error if it is.
 298
 299                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
 300                 $string_handle->execute();
 301
 302                 my @database_page;
 303                 my $page_exists = 0;
 304
 305                 while (@database_page = $string_handle->fetchrow_array()){
 306
 307                         # The page exists so set the page exists value to 1.
 308
 309                         $page_exists = 1;
 310
 311                 }
 312
 313                 if ($page_exists eq 1){
 314
 315                         # The page exists so return an error.
 316
 317                         kiriwrite_error("pagefilenameexists");
 318
 319                 }
 320
 321                 # Get the database name.
 322
 323                 $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
 324                 $string_handle->execute();
 325
 326                 my @database_info       = $string_handle->fetchrow_array();
 327
 328                 my $database_name       = $database_info[0];
 329
 330                 # Convert the values so they don't cause the SQL query
 331                 # to break.
 332
 333                 my $filename_sql                = kiriwrite_convert($pagefilename, "kiriwrite");
 334                 my $pagename_sql                = kiriwrite_convert($pagetitle, "kiriwrite");
 335                 my $pagedescription_sql         = kiriwrite_convert($pagedescription, "kiriwrite");
 336                 my $pagesection_sql             = kiriwrite_convert($pagesection, "kiriwrite");
 337                 my $pagetemplate_sql            = kiriwrite_convert($pagetemplate, "kiriwrite");
 338                 my $pagesettings_sql            = kiriwrite_convert($pagesettings, "kiriwrite");
 339                 my $pagefiledata_sql            = kiriwrite_convert($pagefiledata, "kiriwrite");
 340
 341                 # Create the last modified date.
 342
 343                 my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
 344
 345                 my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
 346
 347                 # Add the page to the database.
 348
 349                 $string_handle          = $database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
 350                         \'' . $filename_sql . '\',
 351                         \'' . $pagename_sql . '\',
 352                         \'' . $pagedescription_sql . '\',
 353                         \'' . $pagesection_sql . '\',
 354                         \'' . $pagetemplate_sql . '\',
 355                         \'' . $pagefiledata_sql . '\',
 356                         \'' . $pagesettings_sql . '\',
 357                         \'' . $pagelastmodified . '\'
 358                 )');
 359                 $string_handle->execute();
 360
 361                 # Convert certain variables so that display properly.
 362
 363                 my $pagetitle_display           = kiriwrite_convert($pagetitle, "normal_display");
 364                 my $database_name_display       = kiriwrite_convert($database_name, "normal_display");
 365
 366                 $pagedata = "<h2>Add Page</h2>";
 367                 $pagedata = $pagedata . "The page called '" . $pagetitle_display . "' was added to the '" . $database_name_display .  "' database successfully.<br><br>";
 368                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $pagedatabase . "\">Return to the page list for the '" . $database_name . "' database.</a>";
 369
 370                 return $pagedata;
 371
 372         } elsif ($confirm eq 0) {
 373
 374                 # The action to create a new page has not been confirmed, so print out a form
 375                 # for adding a page to a database.
 376
 377                 # Check if the page database and template database exists and has valid permissions
 378                 # set and return an error if they don't.
 379
 380                 my $database_page_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
 381                 my $database_page_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db', 1, 1, 0);
 382                 my $database_template_exists            = kiriwrite_fileexists("templates.db");
 383                 my $database_template_permissions       = kiriwrite_filepermissions("templates.db", 1, 0, 0);
 384
 385                 my $template_data = "";
 386
 387                 my $database_handle;
 388                 my $string_handle;
 389
 390                 my $template_warningmessage;
 391                 my $template_warning = 0;
 392
 393                 my @database_template;
 394                 my @database_page;
 395
 396                 if ($database_page_exists eq 1){
 397
 398                         # The page database does not exists so return an
 399                         # error.
 400
 401                         kiriwrite_error("databasemissingfile");
 402
 403                 }
 404
 405                 if ($database_page_permissions eq 1){
 406
 407                         # The page database permissions are invalid so
 408                         # return an error.
 409
 410                         kiriwrite_error("databaseinvalidpermissions");
 411
 412                 }
 413
 414                 if ($database_template_exists eq 1){
 415
 416                         # The template database does not exist so
 417                         # write a message to say that the template
 418                         # database is missing, none assumed.
 419
 420                         $template_warningmessage = "Template database does not exist. No template will be used.";
 421                         $template_warning = 1;
 422
 423                 }
 424
 425                 if ($database_template_permissions eq 1 && $database_template_exists ne 1){
 426
 427                         # The template permissions are invalid so
 428                         # write a message saying that the template
 429                         # database has invalid permissions set,
 430                         # none assumed.
 431
 432                         $template_warningmessage = "Template database has invalid permissions set. No template will be used.";
 433                         $template_warning = 1;
 434
 435                 }
 436
 437                 # Check if the template_warning value is set to 1 and
 438                 # if it isn't then load the template database.
 439
 440                 if ($template_warning eq 0){
 441
 442                         # The template_warning value is not set to 1, so
 443                         # load the template database.
 444
 445                         my $page_filename       = "";
 446                         my $page_name           = "";
 447                         my $template_count      = 0;
 448
 449                         # Load the SQLite database.
 450
 451                         $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
 452                         $string_handle  = $database_handle->prepare("SELECT * FROM kiriwrite_templates ORDER BY templatename asc") or kiriwrite_error("templatedatabaseinvalidformat");
 453                         $string_handle->execute();
 454
 455                         $template_data = "<select name=\"pagetemplate\">";
 456
 457                         # Process each template, getting the filename and template
 458                         # name and put them into the list of templates available.
 459
 460                         while (@database_template = $string_handle->fetchrow_array()){
 461
 462                                 $page_filename  = $database_template[0];
 463                                 $page_name      = $database_template[1];
 464
 465                                 $page_filename  = kiriwrite_convert($page_filename, "normal_display");
 466                                 $page_name      = kiriwrite_convert($page_name, "normal_display");
 467
 468                                 $template_data = $template_data . "<option value=\"" . $page_filename . "\">" . $page_name . " (" . $page_filename . ")</option>";
 469                                 $template_count++
 470
 471                         }
 472
 473                         $template_data = $template_data . "<option value=\"!none\">Don't use a template</option>";
 474                         $template_data = $template_data . "</select>";
 475
 476                         if ($template_count eq 0){
 477
 478                                 # There are no templates in the template database
 479                                 # so write a message saying that no templates
 480                                 # are in the template database.
 481
 482                                 $template_warningmessage = "There are no templates in the template database. No template will be used.";
 483                                 $template_warning = 1;
 484
 485                         }
 486
 487                 }
 488
 489                 # Load the page database and get the page database
 490                 # name.
 491
 492                 $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $pagedatabase . '.db');
 493                 $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info limit 1") or kiriwrite_error("databasefileinvalid");
 494                 $string_handle->execute();
 495
 496                 @database_page          = $string_handle->fetchrow_array();
 497
 498                 my $database_name       = $database_page[0];
 499
 500                 $database_name          = kiriwrite_convert($database_name, "normal_display");
 501                 $pagedatabase           = kiriwrite_convert($pagedatabase, "normal_display");
 502
 503                 $pagedata = $pagedata . "<h2>Add Page</h2>";
 504                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
 505                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
 506                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
 507                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $pagedatabase . "\">";
 508                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
 509                 $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
 510                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
 511                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database</td><td class=\"tablecell2\">" . $database_name . "</td></tr>";
 512                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Name</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagename\" value=\"\" maxlength=\"512\" size=\"64\"></td></tr>";
 513                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Description</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagedescription\" value=\"\" maxlength=\"512\" size=\"64\"></td></tr>";
 514                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Section</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagesection\" value=\"\" maxlength=\"256\" size=\"64\"></td></tr>";
 515
 516                 if ($template_warning eq 1){
 517
 518                         $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"hidden\" name=\"pagetemplate\" value=\"!none\">Page Template</td><td class=\"tablecell2\">" . $template_warningmessage . "</td></tr>";
 519                         $pagedata = $pagedata . "";
 520
 521                 } else {
 522
 523                         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
 524
 525                 }
 526
 527                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Filename</td><td class=\"tablecell2\"><input type=\"input\" name=\"pagefilename\" value=\"\" maxlength=\"256\" size=\"64\"></td></tr>";
 528                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Content</td><td class=\"tablecell2\"><textarea cols=\"50\" rows=\"10\" name=\"pagecontent\" wrap=\"off\"></textarea><br><br>";
 529                 $pagedata = $pagedata . "<div class=\"datalist\"><b>Kiriwrite tags</b><br><br>&lt;kiriwrite:autosection&gt; - Automatic page section name. (Will be blank if page section name is blank).<br>
 530                 &lt;kiriwrite:autotitle&gt; - Automatic title and section name based on page setting.<br>
 531                 &lt;kiriwrite:pagedata&gt; - Page Content<br>
 532                 &lt;kiriwrite:pagetitle&gt; - Page Title based on page setting.<br>
 533                 &lt;kiriwrite:pagename&gt; - Page Name<br>
 534                 &lt;kiriwrite:pagedescription&gt; - Page Description<br>
 535                 &lt;kiriwrite:pagesection&gt; - Page Section<br></div>";
 536                 $pagedata = $pagedata . "</td></tr>";
 537                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell2\"><input type=\"radio\" name=\"pagesettings\" value=\"1\" checked=checked> Use page name and section name.<br><input type=\"radio\" name=\"pagesettings\" value=\"2\"> Use the page name only.<br><input type=\"radio\" name=\"pagesettings\" value=\"3\"> Use the section name only. <br><input type=\"radio\" name=\"pagesettings\" value=\"0\"> Don't use page name or section name.<br></td></tr>";
 538                 $pagedata = $pagedata . "</table>";
 539                 $pagedata = $pagedata . "<br><input type=\"submit\" value=\"Add Page\"> | <input type=\"reset\" value=\"Clear inputted data\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $pagedatabase . "\">Return to the page list.</a>";
 540                 $pagedata = $pagedata . "</form>";
 541
 542                 return $pagedata;
 543
 544         } else {
 545
 546                 # The confirm value is something else than '1' or '0' so
 547                 # return an error.
 548
 549                 kiriwrite_error("invalidvalue");
 550
 551         }
 552
 553
 554
 555 }
 556
 557 sub kiriwrite_page_delete{
 558 #################################################################################
 559 # kiriwrite_page_delete: Deletes a (single) page from a database.               #
 560 #                                                                               #
 561 # Usage:                                                                        #
 562 #                                                                               #
 563 # kiriwrite_page_delete(database, page, [confirm]);                             #
 564 #                                                                               #
 565 # database      Specifies the database to delete from.                          #
 566 # page          Specifies the page to delete.                                   #
 567 # confirm       Confirms the action to delete the page.                         #
 568 #################################################################################
 569
 570         my ($database, $page, $confirm) = @_;
 571
 572         # Load the required Perl modules.
 573
 574         use DBI;
 575
 576         my $pagedata;
 577
 578         # Check if the database filename is valid and return an error if
 579         # it isn't.
 580
 581         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
 582
 583         if ($pagedatabase_filename_check eq 1){
 584
 585                 # The database filename is blank, so return an error.
 586
 587                 kiriwrite_error("blankdatabasepageadd");
 588
 589         } elsif ($pagedatabase_filename_check eq 2){
 590
 591                 # The database filename is invalid, so return an error.
 592
 593                 kiriwrite_error("databasefilenameinvalid");
 594
 595         }
 596
 597         # Check the length the database name and return an error if it's
 598         # too long.
 599
 600         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
 601
 602         if ($pagedatabase_length_check eq 1){
 603
 604                 # The database name is too long, so return an error.
 605
 606                 kiriwrite_error("databasefilenametoolong");
 607
 608         }
 609
 610         # Check if the page name is specified is blank and return an error if
 611         # it is.
 612
 613         if (!$page){
 614
 615                 # The page name is blank, so return an error.
 616
 617                 kiriwrite_error("blankfilename");
 618
 619         }
 620
 621         # If the confirm value is blank, then set the confirm value to 0.
 622
 623         if (!$confirm){
 624
 625                 $confirm = 0;
 626
 627         }
 628
 629         if ($confirm eq 1){
 630
 631                 # The action to delete the selected page from the database
 632                 # has been confirmed.
 633
 634                 # Check that the database exists and has the correct permissions
 635                 # set.
 636
 637                 my $database_check_exists       = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
 638                 my $database_check_permissions  = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
 639
 640                 # Check the results and return an error if needed.
 641
 642                 if ($database_check_exists eq 1){
 643
 644                         # The database file does not exist, so return an error.
 645
 646                         kiriwrite_error("databasemissingfile");
 647
 648                 }
 649
 650                 if ($database_check_permissions eq 1){
 651
 652                         # The database file has invalid permissions set, so
 653                         # return an error.
 654
 655                         kiriwrite_error("databaseinvalidpermissions");
 656
 657                 }
 658
 659                 # Load the SQLite database and get information about the
 660                 # database.
 661
 662                 my $database_handle             = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
 663                 my $string_handle               = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid") or kiriwrite_error("databasefileinvalid");
 664                 $string_handle->execute();
 665
 666                 my @database_info;
 667                 my $database_name;
 668                 @database_info = $string_handle->fetchrow_array();
 669                 $database_name = $database_info[0];
 670
 671                 my $pagefilename_sql            = kiriwrite_convert($page, "kiriwrite");
 672
 673                 # Check if the filename exists and return an error if it
 674                 # isn't.
 675
 676                 $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
 677                 $string_handle->execute();
 678
 679                 my @database_page;
 680                 my $page_found = 0;
 681
 682                 while (@database_page = $string_handle->fetchrow_array()){
 683
 684                         $page_found = 1;
 685
 686                 }
 687
 688                 # Check if the page wasn't found and return an error if it
 689                 # didn't.
 690
 691                 if ($page_found eq 0){
 692
 693                         # Page wasn't found in the database so return
 694                         # an error.
 695
 696                         kiriwrite_error("pagefilenamedoesnotexist");
 697
 698                 }
 699
 700                 # Get information about the page (mainly the name).
 701
 702                 $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
 703                 $string_handle->execute();
 704
 705                 my $page_name;
 706                 @database_page  = $string_handle->fetchrow_array();
 707                 $page_name      = $database_page[1];
 708
 709                 # Delete the page from the database.
 710
 711                 $string_handle                  = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\'');
 712                 $string_handle->execute();
 713
 714                 # Convert the values before writing them.
 715
 716                 my $database_out        = kiriwrite_convert($database, "normal_display");
 717                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
 718                 my $page_name_out       = kiriwrite_convert($page_name, "normal_display");
 719
 720                 # Write out a message saying that the selected page from
 721                 # the database has been deleted.
 722
 723                 $pagedata = "<h2>Page Deleted</h2>";
 724                 $pagedata = $pagedata . "The page named '" . $page_name_out . "' was deleted from the '" . $database_name_out . "' database. <br><br>";
 725                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the '" . $database_name_out . "' database.</a>";
 726
 727                 return $pagedata;
 728
 729         } elsif ($confirm eq 0){
 730
 731                 # Check that the database exists and has the correct permissions
 732                 # set.
 733
 734                 my $database_check_exists       = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
 735                 my $database_check_permissions  = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
 736
 737                 # Check the results and return an error if needed.
 738
 739                 if ($database_check_exists eq 1){
 740
 741                         # The database file does not exist, so return an error.
 742
 743                         kiriwrite_error("databasemissingfile");
 744
 745                 }
 746
 747                 if ($database_check_permissions eq 1){
 748
 749                         # The database file has invalid permissions set, so
 750                         # return an error.
 751
 752                         kiriwrite_error("databaseinvalidpermissions");
 753
 754                 }
 755
 756                 # Load the SQLite database and get information about the
 757                 # database.
 758
 759                 my $database_handle             = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
 760                 my $string_handle               = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid") or kiriwrite_error("databasefileinvalid");
 761                 $string_handle->execute();
 762
 763                 my @database_info;
 764                 my $database_name;
 765                 @database_info = $string_handle->fetchrow_array();
 766                 $database_name = $database_info[0];
 767
 768                 my $pagefilename_sql            = kiriwrite_convert($page, "kiriwrite");
 769
 770                 # Check if the filename exists and return an error if it
 771                 # isn't.
 772
 773                 $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
 774                 $string_handle->execute();
 775
 776                 my $page_found = 0;
 777
 778                 my @database_page;
 779
 780                 while (@database_page = $string_handle->fetchrow_array()){
 781
 782                         $page_found = 1;
 783
 784                 }
 785
 786                 # Check if the page wasn't found and return an error if it
 787                 # didn't.
 788
 789                 if ($page_found eq 0){
 790
 791                         # Page wasn't found in the database so return
 792                         # an error.
 793
 794                         kiriwrite_error("pagefilenamedoesnotexist");
 795
 796                 }
 797
 798                 # Get information about the page (mainly the name).
 799
 800                 $string_handle                  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename_sql . '\' LIMIT 1');
 801                 $string_handle->execute();
 802
 803                 my $page_name;
 804                 @database_page  = $string_handle->fetchrow_array();
 805                 $page_name      = $database_page[1];
 806
 807                 # Convert the values so that they can be displayed properly.
 808
 809                 my $page_name_out       = kiriwrite_convert($page_name, "normal_display");
 810                 my $database_out        = kiriwrite_convert($database, "normal_display");
 811                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
 812                 my $page_out            = kiriwrite_convert($page, "normal_display");
 813
 814                 # Write a message asking the user to confirm the deletion of the
 815                 # page.
 816
 817                 $pagedata = "<form>";
 818                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
 819                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
 820                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
 821                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"page\" value=\"" . $page_out . "\">";
 822                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";;
 823                 $pagedata = $pagedata . "<h2>Delete page '" . $page_name_out . "'</h2>";
 824                 $pagedata = $pagedata . "Are you sure you want to delete '" . $page_name_out . "' from the '" . $database_name_out . "' database?<br><br>";
 825                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete the page\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out  . "\">No, return to the '" . $database_name_out . "' database.</a>";
 826                 $pagedata = $pagedata . "</form>";
 827
 828
 829                 return $pagedata;
 830
 831         } else {
 832
 833                 # Another page deletion type was specified, so return an error.
 834
 835                 kiriwrite_error("invalidoption");
 836
 837         }
 838
 839 }
 840
 841 sub kiriwrite_page_edit{
 842 #################################################################################
 843 # kiriwrite_page_edit: Edits a page from a database.                            #
 844 #                                                                               #
 845 # Usage:                                                                        #
 846 #                                                                               #
 847 # kiriwrite_page_edit(database, filename, newname, newfilename, newdescription, #
 848 #                       newsection, newtemplate,  newsettings, newpagecontent   #
 849 #                       confirm);                                               #
 850 #                                                                               #
 851 # database       Specifies the database to edit from.                           #
 852 # filename       Specifies the filename to use.                                 #
 853 # newfilename    Specifies the new page filename to use.                        #
 854 # newname        Specifies the new page name to use.                            #
 855 # newdescription Specifies the new description for the page.                    #
 856 # newsection     Specifies the new section name to use.                         #
 857 # newtemplate    Specifies the new template filename to use.                    #
 858 # newsettings    Specifies the new page settings to use.                        #
 859 # newpagecontent Specifies the new page content to use.                         #
 860 # confirm        Confirms the action to edit the page.                          #
 861 #################################################################################
 862
 863         # Get the values that have been passed to the subroutine.
 864
 865         my ($database, $pagefilename, $pagenewfilename, $pagenewtitle, $pagenewdescription, $pagenewsection, $pagenewtemplate, $pagenewsettings, $pagenewcontent, $confirm) = @_;
 866
 867         # Load the required Perl modules.
 868
 869         use DBI;
 870
 871         my $pagedata = "";
 872
 873         # Check if the confirm value is blank and if it is, then set it to '0'.
 874
 875         if (!$confirm){
 876
 877                 $confirm = 0;
 878
 879         }
 880
 881         # Check if the confirm value is more than one character long and if it
 882         # is then return an error.
 883
 884         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
 885
 886         # Check if the database filename is valid and return an error if
 887         # it isn't.
 888
 889         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
 890
 891         if ($pagedatabase_filename_check eq 1){
 892
 893                 # The database filename is blank, so return an error.
 894
 895                 kiriwrite_error("blankdatabasepageadd");
 896
 897         } elsif ($pagedatabase_filename_check eq 2){
 898
 899                 # The database filename is invalid, so return an error.
 900
 901                 kiriwrite_error("databasefilenameinvalid");
 902
 903         }
 904
 905         # Check the length the database name and return an error if it's
 906         # too long.
 907
 908         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
 909
 910         if ($pagedatabase_length_check eq 1){
 911
 912                 # The database name is too long, so return an error.
 913
 914                 kiriwrite_error("databasefilenametoolong");
 915
 916         }
 917
 918         # Check if the page identification number is blank (which it shouldn't
 919         # be) and if it is, then return an error.
 920
 921         if (!$pagefilename){
 922
 923                 kiriwrite_error("blankfilename");
 924
 925         }
 926
 927         # Check if the confirm value is '1' and if it is, edit the specified
 928         # page in the database.
 929
 930         if ($confirm eq 1){
 931
 932                 # Check if the new page filename is blank.
 933
 934                 if (!$pagenewfilename){
 935
 936                         # The page filename is blank so return an error.
 937
 938                         kiriwrite_error("pagefilenameblank");
 939
 940                 }
 941
 942                 # The action to edit a page has been confirmed so check the
 943                 # variables recieved are UTF8 compiliant before converting.
 944
 945                 kiriwrite_variablecheck($database, "utf8", 0, 0);
 946                 kiriwrite_variablecheck($pagefilename, "utf8", 0, 0);
 947                 kiriwrite_variablecheck($pagenewfilename, "utf8", 0, 0);
 948                 kiriwrite_variablecheck($pagenewtitle, "utf8", 0, 0);
 949                 kiriwrite_variablecheck($pagenewdescription, "utf8", 0, 0);
 950                 kiriwrite_variablecheck($pagenewsection, "utf8", 0, 0);
 951                 kiriwrite_variablecheck($pagenewsettings, "utf8", 0, 0);
 952                 kiriwrite_variablecheck($pagenewtemplate, "utf8", 0, 0);
 953                 kiriwrite_variablecheck($pagenewcontent, "utf8", 0, 0);
 954
 955                 # Convert the variables into proper UTF8 variables.
 956
 957                 $database               = kiriwrite_utf8convert($database);
 958                 $pagefilename           = kiriwrite_utf8convert($pagefilename);
 959                 $pagenewfilename        = kiriwrite_utf8convert($pagenewfilename);
 960                 $pagenewtitle           = kiriwrite_utf8convert($pagenewtitle);
 961                 $pagenewdescription     = kiriwrite_utf8convert($pagenewdescription);
 962                 $pagenewsection         = kiriwrite_utf8convert($pagenewsection);
 963                 $pagenewsettings        = kiriwrite_utf8convert($pagenewsettings);
 964                 $pagenewtemplate        = kiriwrite_utf8convert($pagenewtemplate);
 965                 $pagenewcontent         = kiriwrite_utf8convert($pagenewcontent);
 966
 967                 # Check the lengths of the variables.
 968
 969                 my $pagenewfilename_maxlength_check     = kiriwrite_variablecheck($pagenewfilename, "maxlength", 256, 1);
 970                 my $pagenewtitle_maxlength_check        = kiriwrite_variablecheck($pagenewtitle, "maxlength", 256, 1);
 971                 my $pagenewdescription_maxlength_check  = kiriwrite_variablecheck($pagenewdescription, "maxlength", 512, 1);
 972                 my $pagenewsection_maxlength_check      = kiriwrite_variablecheck($pagenewsection, "maxlength", 256, 1);
 973                 my $pagenewsettings_maxlength_check     = kiriwrite_variablecheck($pagenewsettings, "maxlength", 1, 1);
 974                 my $pagenewtemplate_maxlength_check     = kiriwrite_variablecheck($pagenewtemplate, "maxlength", 64, 1);
 975
 976                 # Check each result to see if the length of the variable
 977                 # is valid and return an error if it isn't.
 978
 979                 if ($pagenewfilename_maxlength_check eq 1){
 980
 981                         # The new page filename given is too long, so return an error.
 982
 983                         kiriwrite_error("pagefilenametoolong");
 984
 985                 }
 986
 987                 if ($pagenewtitle_maxlength_check eq 1){
 988
 989                         # The new page title given is too long, so return an error.
 990
 991                         kiriwrite_error("pagetitletoolong");
 992
 993                 }
 994
 995                 if ($pagenewdescription_maxlength_check eq 1){
 996
 997                         # The new page description given is too long, so return an error.
 998
 999                         kiriwrite_error("pagedescriptiontoolong");
1000
1001                 }
1002
1003                 if ($pagenewsection_maxlength_check eq 1){
1004
1005                         # The new page section given is too long, so return an error.
1006
1007                         kiriwrite_error("pagesectiontoolong");
1008
1009                 }
1010
1011                 if ($pagenewsettings_maxlength_check eq 1){
1012
1013                         # The new page settings given is too long, so return an error.
1014
1015                         kiriwrite_error("pagesettingstoolong");
1016
1017                 }
1018
1019                 if ($pagenewtemplate_maxlength_check eq 1){
1020
1021                         # The new page template given is too long, so return an error.
1022
1023                         kiriwrite_error("pagetemplatefilenametoolong");
1024
1025                 }
1026
1027                 # Check if the new page filename and new page settings
1028                 # are valid.
1029
1030                 my $pagenewfilename_filename_check      = kiriwrite_variablecheck($pagenewfilename, "page_filename", 0, 1);
1031                 my $pagenewsettings_settings_check      = kiriwrite_variablecheck($pagenewsettings, "pagesetting", 0, 1);
1032                 my $pagetemplate_filename_check = 0;
1033
1034                 if ($pagenewtemplate ne "!none"){
1035
1036                         # A template is being used so check the filename of the
1037                         # template.
1038
1039                         $pagetemplate_filename_check    = kiriwrite_variablecheck($pagenewtemplate, "page_filename", 0, 1);
1040
1041                 }
1042
1043                 # Check each result to see if the variables have passed
1044                 # their tests and return an error if they haven't.
1045
1046                 if ($pagenewfilename_filename_check eq 1){
1047
1048                         # The new page filename is invalid, so return an error.
1049
1050                         kiriwrite_error("pagefilenameinvalid");
1051
1052                 }
1053
1054                 if ($pagenewsettings_settings_check eq 1){
1055
1056                         # The new page settings is invalid, so return an error.
1057
1058                         kiriwrite_error("pagesettingsinvalid");
1059
1060                 }
1061
1062                 if ($pagetemplate_filename_check eq 1){
1063
1064                         # The template filename given is invalid, so return an error
1065
1066                         kiriwrite_error("templatefilenameinvalid");
1067
1068                 }
1069
1070                 # Check if the page database exists and the permissions set for
1071                 # it are valid.
1072
1073                 my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1074                 my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
1075
1076                 if ($database_exists eq 1){
1077
1078                         # The database does not exist, so return an error.
1079
1080                         kiriwrite_error("databasemissingfile");
1081
1082                 }
1083
1084                 if ($database_permissions eq 1){
1085
1086                         # The database permissions are invalid, so return
1087                         # an error.
1088
1089                         kiriwrite_error("databaseinvalidpermissions");
1090
1091                 }
1092
1093                 # Load the SQLite database.
1094
1095                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1096
1097                 # Check if the page exists in the page database and return
1098                 # an error if it doesn't.
1099
1100                 my $pagefilename_sql    = kiriwrite_convert($pagefilename, "kiriwrite");
1101
1102                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
1103                 $string_handle->execute();
1104
1105                 my $page_exists = 0;
1106                 my @database_pages;
1107
1108                 # Check if a result has returned (meaning that the
1109                 # page with that filename exists.
1110
1111                 while(@database_pages = $string_handle->fetchrow_array()){
1112
1113                         # The page exists so set the value to 1.
1114
1115                         $page_exists = 1;
1116
1117                 }
1118
1119                 if ($page_exists eq 0){
1120
1121                         # The page does not exist, so return an error.
1122
1123                         kiriwrite_error("pagefilenamedoesnotexist");
1124
1125                 }
1126
1127                 # Get the current date and time.
1128
1129                 my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
1130
1131                 my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
1132
1133                 # Prepare for the page's values to be changed.
1134
1135                 $pagefilename_sql               = kiriwrite_convert($pagefilename, "kiriwrite");
1136                 my $pagenewfilename_sql         = kiriwrite_convert($pagenewfilename, "kiriwrite");
1137                 my $pagenewtitle_sql            = kiriwrite_convert($pagenewtitle, "kiriwrite");
1138                 my $pagenewdescription_sql      = kiriwrite_convert($pagenewdescription, "kiriwrite");
1139                 my $pagenewsection_sql          = kiriwrite_convert($pagenewsection, "kiriwrite");
1140                 my $pagenewtemplate_sql         = kiriwrite_convert($pagenewtemplate, "kiriwrite");
1141                 my $pagenewsettings_sql         = kiriwrite_convert($pagenewsettings, "kiriwrite");
1142                 my $pagenewcontent_sql          = kiriwrite_convert($pagenewcontent, "kiriwrite");
1143                 my $pagelastmodified_sql        = kiriwrite_convert($pagelastmodified, "kiriwrite");
1144
1145                 # Edit the page in the database.
1146
1147                 $string_handle  = $database_handle->prepare('UPDATE kiriwrite_database_pages SET filename = \'' . $pagenewfilename_sql . '\', pagename = \'' . $pagenewtitle_sql . '\', pagedescription = \'' . $pagenewdescription_sql . '\', pagesection = \'' . $pagenewsection_sql . '\', pagetemplate = \'' . $pagenewtemplate_sql . '\', pagedata = \'' . $pagenewcontent_sql . '\', pagesettings = \'' . $pagenewsettings_sql . '\', lastmodified = \'' . $pagelastmodified_sql . '\' WHERE filename = \'' . $pagefilename_sql . '\'');
1148                 $string_handle->execute();
1149
1150                 # Get the database name.
1151
1152                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
1153                 $string_handle->execute();
1154
1155                 my @database_info;
1156                 my $database_name;
1157
1158                 @database_info  = $string_handle->fetchrow_array();
1159                 $database_name  = $database_info[0];
1160
1161                 # Convert certain values so that they can be displayed
1162                 # properly.
1163
1164                 my $pagenewtitle_out            = kiriwrite_convert($pagenewtitle, "normal_display");
1165                 my $database_out                = kiriwrite_convert($database, "normal_display");
1166                 my $database_name_out           = kiriwrite_convert($database_name, "normal_display");
1167
1168                 # Write out the message to say that the page has been
1169                 # edited.
1170
1171                 $pagedata = "<h2>Page Edited</h2>";
1172                 $pagedata = $pagedata . "The page '" . $pagenewtitle_out . "' has been edited.<br><br>";
1173                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database</a>";
1174
1175                 return $pagedata;
1176
1177         } elsif ($confirm eq 0) {
1178
1179                 # Check if the database exists and that the permissions
1180                 # for the database are valid.
1181
1182                 my $database_file_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1183                 my $database_file_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1184
1185                 if ($database_file_exists eq 1){
1186
1187                         # The database with the filename given does
1188                         # not exist, so return an error.
1189
1190                         kiriwrite_error("databasemissingfile");
1191
1192                 }
1193
1194                 if ($database_file_permissions eq 1){
1195
1196                         # The file permissions of the database given
1197                         # are invalid so return an error.
1198
1199                         kiriwrite_error("databaseinvalidpermissions");
1200
1201                 }
1202
1203                 # Load the SQLite database and check if the file exists.
1204
1205                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1206                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
1207                 $string_handle->execute();
1208
1209                 my $page_count = 0;
1210                 my @database_pages;
1211                 my @database_info;
1212                 my @database_templates;
1213                 my $template_data;
1214                 my $template_filename;
1215                 my $template_name;
1216                 my $template_found = 0;
1217
1218                 while (@database_pages = $string_handle->fetchrow_array()){
1219
1220                         $page_count = 1;
1221
1222                 }
1223
1224                 if ($page_count eq 0){
1225
1226                         # The page does not exist in the template database, so
1227                         # return an error.
1228
1229                         kiriwrite_error("pagefilenamedoesnotexist");
1230
1231                 }
1232
1233                 # Get the database name.
1234
1235                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
1236                 $string_handle->execute();
1237                 @database_info  = $string_handle->fetchrow_array();
1238
1239                 my $database_name = $database_info[0];
1240
1241                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $pagefilename . '\' LIMIT 1');
1242                 $string_handle->execute();
1243                 @database_pages = $string_handle->fetchrow_array();
1244
1245                 # Get the variables and convert them so that they can be displayed
1246                 # properly.
1247
1248                 my $data_filename               = kiriwrite_convert($database_pages[0], "normal_display");
1249                 my $data_name                   = kiriwrite_convert($database_pages[1], "normal_display");
1250                 my $data_description            = kiriwrite_convert($database_pages[2], "normal_display");
1251                 my $data_section                = kiriwrite_convert($database_pages[3], "normal_display");
1252                 my $data_template               = kiriwrite_convert($database_pages[4], "normal_display");
1253                 my $data_content                = kiriwrite_convert($database_pages[5], "normal_display");
1254                 my $data_settings               = kiriwrite_convert($database_pages[6], "normal_display");
1255                 my $data_lastmodified           = kiriwrite_convert(kiriwrite_convert($database_pages[7], "date"), "normal_display");
1256
1257                 # Get the template list and select the template that is being used by
1258                 # the page, check the permissions and if the template database exists.
1259
1260                 my $template_warning;
1261
1262                 my $template_file_exists        = kiriwrite_fileexists("templates.db");
1263                 my $template_file_permissions   = kiriwrite_filepermissions("templates.db", 1, 0, 0);
1264
1265                 if ($template_file_exists eq 1){
1266
1267                         # The template database does not exist, so write a warning messsage.
1268
1269                         $template_warning = "The template database does not exist. Existing template settings for page kept.";
1270
1271                 }
1272
1273                 if ($template_file_permissions eq 1 && $template_file_exists ne 1){
1274
1275                         # The template database has invalid permissions set, so write a warning message.
1276
1277                         $template_warning = "The template database has invalid permissions set. Existing template settings for page kept.";
1278
1279                 }
1280
1281                 # Get the list of templates.
1282
1283                 if (!$template_warning){
1284
1285                         # Load the templates database and get the templates.
1286
1287                         $database_handle        = DBI->connect("dbi:SQLite:templates.db");
1288
1289                         $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $template_warning = "The template database is in an invalid format. Existing template settings kept.";
1290
1291                         if (!$template_warning){
1292
1293                                 $string_handle->execute();
1294
1295                                 $template_data = "<select name=\"pagetemplate\">";
1296
1297                                 while (@database_templates = $string_handle->fetchrow_array()){
1298
1299                                         # Get the filename and name of the database.
1300
1301                                         $template_filename      = $database_templates[0];
1302                                         $template_name          = $database_templates[1];
1303
1304                                         # Convert the values so that they can be displayed in the list.
1305
1306                                         $template_filename      = kiriwrite_convert($template_filename, "normal_display");
1307                                         $template_name          = kiriwrite_convert($template_name, "normal_display");
1308
1309                                         # Append the template filename and name and make it the selected
1310                                         # template if that is the template the page is using.
1311
1312                                         if ($data_template eq $template_filename && !$template_found){
1313
1314                                                 $template_data = $template_data .  "<option value=\"" . $template_filename . "\" selected>" . $template_name . " (" . $template_filename .")</option>";
1315                                                 $template_found = 1;
1316
1317                                         } else {
1318
1319                                                 $template_data = $template_data .  "<option value=\"" . $template_filename . "\">" . $template_name . " (" . $template_filename .")</option>";
1320
1321                                         }
1322
1323                                 }
1324
1325                         }
1326
1327                         # Add the option to not use a template at all. Check if the
1328                         # template filename is set to not use a template.
1329
1330                         if ($data_template eq "!none"){
1331
1332                                 # The template filename is set to use no template
1333                                 # at all.
1334
1335                                 $template_data = $template_data . "<option value=\"!none\" selected>Don't use a template</option>";
1336
1337                         } else {
1338
1339                                 # The template filename is not set to use no
1340                                 # template at all.
1341
1342                                 $template_data = $template_data . "<option value=\"!none\">Don't use a template</option>";
1343
1344                         }
1345
1346                         # Check if the template filename was found
1347                         # in the template database and use the
1348                         # current template name if not.
1349
1350                         if ($template_found eq 0 && $data_template ne "!none"){
1351
1352                                 # The template with the filename given was not found.
1353
1354                                 $template_data = $template_data . "<option class=\"warningoption\" value=\"" . $data_template . "\" selected>Keep current template filename (" . $data_template . ")</option>";
1355
1356                         }
1357                         $template_data = $template_data . "</select>";
1358
1359                 }
1360
1361                 # Begin writing out the form for editing the selected page.
1362
1363                 $pagedata = "<h2>Editing Page '" . $data_name . "'</h2>";
1364                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
1365                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
1366                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
1367                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database . "\">";
1368                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"page\" value=\"" . $pagefilename . "\">";
1369                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
1370                 $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">";
1371                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
1372                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database</td><td class=\"tablecell2\">" . $database_name . "</td></tr>";
1373                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Name</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagename\" maxlength=\"256\" size=\"64\"  value=\"" . $data_name ."\"></td></tr>";
1374                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Description</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagedescription\" maxlength=\"512\" size=\"64\" value=\"" . $data_description . "\"=</td></tr>";
1375                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Section</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagesection\" maxlength=\"256\" size=\"64\" value=\"" . $data_section . "\"></td></tr>";
1376
1377                 if ($template_warning){
1378
1379                         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\"><input type=\"hidden\" name=\"pagetemplate\" value=\"" . $data_template . "\"><b>" . $data_template . "</b><br>" . $template_warning . "</td></tr>";
1380
1381                 } else {
1382
1383                         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
1384
1385                 }
1386
1387                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Filename</td><td class=\"tablecell2\"><input type=\"text\" name=\"pagefilename\" value=\"" . $data_filename . "\" maxlength=\"256\" size=\"64\"></td></tr>";
1388                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Content</td><td class=\"tablecell2\"><textarea name=\"pagecontent\" rows=\"10\" cols=\"50\" wrap=\"off\">" . $data_content . "</textarea><br><br>";
1389                 $pagedata = $pagedata . "<div class=\"datalist\"><b>Kiriwrite tags</b><br><br>&lt;kiriwrite:autosection&gt; - Automatic page section name. (Will be blank if page section name is blank).<br>
1390                 &lt;kiriwrite:autotitle&gt; - Automatic title and section name based on page setting.<br>
1391                 &lt;kiriwrite:pagedata&gt; - Page Content<br>
1392                 &lt;kiriwrite:pagetitle&gt; - Page Title based on page setting.<br>
1393                 &lt;kiriwrite:pagename&gt; - Page Name<br>
1394                 &lt;kiriwrite:pagedescription&gt; - Page Description<br>
1395                 &lt;kiriwrite:pagesection&gt; - Page Section<br></div>";
1396                 $pagedata = $pagedata . "</td></tr>";
1397                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell2\">";
1398
1399                 # Check the page settings value and set the currently selected
1400                 # option to what the settings value is set to.
1401
1402                 if ($data_settings eq 1){
1403
1404                         # The selected option is to use the page name and
1405                         # section name so make sure it is selected.
1406
1407                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"1\" checked> Use page name and section name.<br>";
1408
1409                 } else {
1410
1411                         # The setting is not the one being checked for
1412                         # so write the option out as normal.
1413
1414                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"1\"> Use page name and section name.<br>";
1415
1416                 }
1417
1418                 if ($data_settings eq 2){
1419
1420                         # The selected option is to use the page name
1421                         # only so make sure it is selected.
1422
1423                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"2\" checked> Use the page name only.<br>";
1424
1425                 } else {
1426
1427                         # The setting is not the one being checked for
1428                         # so write the option out as normal.
1429
1430                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"2\"> Use the page name only.<br>";
1431
1432                 }
1433
1434                 if ($data_settings eq 3){
1435
1436                         # The selected option is to use the section name
1437                         # only so make sure it is selected.
1438
1439                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"3\" checked> Use the section name only. <br>";
1440
1441                 } else {
1442
1443                         # The setting is not the one being checked for
1444                         # so write the option out as normal.
1445
1446                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"3\"> Use the section name only. <br>";
1447
1448                 }
1449
1450                 if ($data_settings eq 0){
1451
1452                         # The selected option is to not use the page name
1453                         # or the section name.
1454
1455                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"0\" checked> Don't use page name or section name.<br></td></tr>";
1456
1457                 } else {
1458
1459                         # The setting is not the one being checked for
1460                         # so write the option out as normal.
1461
1462                         $pagedata = $pagedata . "<input type=\"radio\" name=\"pagesettings\" value=\"0\"> Don't use page name or section name.<br></td></tr>";
1463
1464                 }
1465
1466                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Page Last Modified</td><td class=\"tablecell2\">" . $data_lastmodified  . "</td></tr>";
1467                 $pagedata = $pagedata . "</table>";
1468                 $pagedata = $pagedata . "<br><input type=\"submit\" value=\"Edit Page\"> | <input type=\"reset\" value=\"Reset page values\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database . "\">Return to the page list for '" . $database_name . "'</a>";
1469                 $pagedata = $pagedata . "</form>";
1470
1471                 return $pagedata;
1472
1473         } else {
1474
1475                 # The confirm value is a value other than '0' and '1' so
1476                 # return an error.
1477
1478                 kiriwrite_error("invalidvalue");
1479
1480         }
1481
1482 }
1483
1484 sub kiriwrite_page_multidelete{
1485 #################################################################################
1486 # kiriwrite_page_multidelete: Delete mulitple pages from the database.          #
1487 #                                                                               #
1488 # Usage:                                                                        #
1489 #                                                                               #
1490 # kiriwrite_page_multidelete(database, confirm, filelist);                      #
1491 #                                                                               #
1492 # database      Specifies the database to delete multiple pages from.           #
1493 # confirm       Confirms the action to delete the selected pages from the       #
1494 #               database.                                                       #
1495 # filelist      The list of files to delete from the selected database.         #
1496 #################################################################################
1497
1498         # Get the information passed to the subroutine.
1499
1500         my ($database, $confirm, @filelist) = @_;
1501
1502         # Load the needed Perl modules.
1503
1504         use DBI;
1505
1506         # Define a variable for later on.
1507
1508         my $pagedata;
1509
1510         # Check if the database name is blank and return an error if
1511         # it is.
1512
1513         if (!$database){
1514
1515                 # The database name is blank so return an error.
1516
1517                 kiriwrite_error("databasenameblank");
1518
1519         }
1520
1521         # Check if the page database exists and the permissions set for
1522         # it are valid.
1523
1524         my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1525         my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
1526
1527         if ($database_exists eq 1){
1528
1529                 # The database does not exist, so return an error.
1530
1531                 kiriwrite_error("databasemissingfile");
1532
1533         }
1534
1535         if ($database_permissions eq 1){
1536
1537                 # The database permissions are invalid, so return
1538                 # an error.
1539
1540                 kiriwrite_error("databaseinvalidpermissions");
1541
1542         }
1543
1544         # Check if the file list array has any values and return
1545         # an error if it doesn't.
1546
1547         if (!@filelist){
1548
1549                 # The page list really is blank so return
1550                 # an error.
1551
1552                 kiriwrite_error("nopagesselected");
1553         }
1554
1555         # Check if the database filename is valid and return an error if
1556         # it isn't.
1557
1558         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
1559
1560         if ($pagedatabase_filename_check eq 1){
1561
1562                 # The database filename is blank, so return an error.
1563
1564                 kiriwrite_error("blankdatabasepageadd");
1565
1566         } elsif ($pagedatabase_filename_check eq 2){
1567
1568                 # The database filename is invalid, so return an error.
1569
1570                 kiriwrite_error("databasefilenameinvalid");
1571
1572         }
1573
1574         # Check the length the database name and return an error if it's
1575         # too long.
1576
1577         my $pagedatabase_length_check   = kiriwrite_variablecheck($database, "maxlength", 64, 1);
1578
1579         if ($pagedatabase_length_check eq 1){
1580
1581                 # The database name is too long, so return an error.
1582
1583                 kiriwrite_error("databasefilenametoolong");
1584
1585         }
1586
1587         # Check if the confirm value is blank and if it is, then
1588         # set it to 0.
1589
1590         if (!$confirm){
1591
1592                 # The confirm value is blank so set the confirm value
1593                 # to 0.
1594
1595                 $confirm = 0;
1596
1597         }
1598
1599         if ($confirm eq 1){
1600
1601                 # The action to delete multiple pages from the database has
1602                 # been confirmed.
1603
1604                 # Load the SQLite Database and get info about the database.
1605
1606                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1607                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
1608                 $string_handle->execute();
1609
1610                 my @database_info       = $string_handle->fetchrow_array();
1611                 my $database_name       = $database_info[0];
1612
1613                 # Define some variables for later.
1614
1615                 my @database_page;
1616                 my $filelist_filename;
1617                 my $deleted_list;
1618                 my $page_name;
1619                 my $page_found = 0;
1620
1621                 $deleted_list = "";
1622
1623                 foreach $filelist_filename (@filelist){
1624
1625                         # Check if the page exists and skip to the next
1626                         # file if it doesn't exist.
1627
1628                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1');
1629                         $string_handle->execute();
1630
1631                         while (@database_page = $string_handle->fetchrow_array()){
1632                                 $page_found = 1;
1633                         }
1634
1635                         if ($page_found eq 0){
1636
1637                                 next;
1638
1639                         }
1640
1641                         # Get the page name.
1642
1643                         $string_handle->execute();
1644                         @database_page  = $string_handle->fetchrow_array();
1645                         $page_name      = $database_page[1];
1646
1647                         # Delete the page.
1648
1649                         $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename  . '\'');
1650                         $string_handle->execute();
1651
1652                         # Append the page name and page filename to the list
1653                         # of deleted pages.
1654
1655                         $deleted_list   = $deleted_list . kiriwrite_convert($page_name, "normal_display") . " (" . $filelist_filename . ")" . "<br>";
1656                         $page_found = 0;
1657
1658                 }
1659
1660                 $string_handle  = $database_handle->prepare('VACUUM');
1661                 $string_handle->execute();
1662
1663                 my $database_out        = kiriwrite_convert($database, "normal_display");
1664                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
1665
1666                 $pagedata = "<h2>Selected pages deleted</h2>";
1667                 $pagedata = $pagedata . "The following pages were deleted from the '" . $database_name_out . "' database:<br><br>";
1668                 $pagedata = $pagedata . "<div class=\"datalist\">";
1669                 $pagedata = $pagedata . $deleted_list;
1670                 $pagedata = $pagedata . "</div><br>";
1671                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
1672
1673                 return $pagedata;
1674
1675         } elsif ($confirm eq 0){
1676
1677                 # The action to delete multiple pages from the database has
1678                 # not been confirmed, so write a form asking the user to confirm
1679                 # the deletion of those pages.
1680
1681                 # Load the SQLite Database and get info about the database.
1682
1683                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1684                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
1685                 $string_handle->execute();
1686
1687                 my @database_info       = $string_handle->fetchrow_array();
1688                 my $database_name       = $database_info[0];
1689
1690                 # Define some variables for later.
1691
1692                 my @page_info;
1693                 my @pagenames;
1694                 my @filenames;
1695                 my $pagename;
1696                 my $filelist_filename;
1697                 my $filelist_filename_sql;
1698                 my $database_name_out;
1699                 my $pagenameslist;
1700                 my $pagenameslist_out;
1701                 my $pageseek = 0;
1702                 my $pagefound = 0;
1703
1704                 # Process each filename given.
1705
1706                 foreach $filelist_filename (@filelist){
1707
1708                         $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
1709                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
1710
1711                         $string_handle->execute();
1712
1713                         # Check if the filename given exists and if it
1714                         # doesn't then skip this filename and go onto
1715                         # the next filename.
1716
1717                         while (@page_info = $string_handle->fetchrow_array()){
1718
1719                                 $pagefound = 1;
1720
1721                         }
1722
1723                         if ($pagefound eq 0){
1724
1725                                 next;
1726
1727                         }
1728
1729                         # Get the data again.
1730
1731                         $string_handle->execute();
1732                         @page_info      = $string_handle->fetchrow_array();
1733
1734                         # Add the page name and file name to their seperate
1735                         # arrays.
1736
1737                         $pagenames[$pageseek]   = $page_info[1];
1738                         $filenames[$pageseek]   = $page_info[0];
1739
1740                         # Increment the page seek counter and reset the
1741                         # page found value.
1742
1743                         $pageseek++;
1744                         $pagefound = 0;
1745
1746                 }
1747
1748                 $pageseek = 0;
1749
1750                 $pagenameslist = "";
1751
1752                 foreach $pagename (@pagenames){
1753
1754                         if (!$pagename){
1755
1756                                 $pagenameslist = $pagenameslist . "<i>No page name</i> (" . $filenames[$pageseek] . ")<br>";
1757
1758                         } else {
1759
1760                                 $pagenameslist = $pagenameslist . kiriwrite_convert($pagename, "normal_display") . " (" . kiriwrite_convert($filenames[$pageseek], "normal_display") . ")<br>";
1761
1762                         }
1763
1764                         $pageseek++;
1765
1766                 }
1767
1768                 # Check if any files were selected and return
1769                 # an error if there wasn't.
1770
1771                 if ($pageseek eq 0){
1772
1773                         # No pages were selected so return an error.
1774
1775                         kiriwrite_error("nopagesselected");
1776
1777                 }
1778
1779                 # Convert the values so that they display properly.
1780
1781                 $database_name_out      = kiriwrite_convert($database_name, "normal_display");
1782                 my $database_out                = kiriwrite_convert($database, "normal_display");
1783
1784                 # Write the form for displaying pages.
1785
1786                 $pagedata = "<h2>Delete multiple pages</h2>";
1787                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
1788                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
1789                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multidelete\">";
1790                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
1791                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
1792                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $pageseek . "\">";
1793
1794                 $pageseek = 1;
1795
1796                 foreach $filelist_filename (@filenames){
1797
1798                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
1799                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filenames[$pageseek - 1] . "\">";
1800
1801                         $pageseek++;
1802
1803                 }
1804
1805
1806
1807                 $pagedata = $pagedata . "Are you sure you want to delete the selected pages below from the '" . $database_name_out . "' database?<br><br>";
1808                 $pagedata = $pagedata . "<div class=\"datalist\">" . $pagenameslist . "</div><br>";
1809                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete selected\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">No, return to the list for '" . $database_name_out . "' database.</a>";
1810                 $pagedata = $pagedata . "</form>";
1811
1812                 return $pagedata;
1813
1814         } else {
1815
1816                 # A confirm value other than 0 or 1 is given, so
1817                 # return an error.
1818
1819                 kiriwrite_error("invaildvalue");
1820
1821         }
1822
1823 }
1824
1825 sub kiriwrite_page_multimove{
1826 #################################################################################
1827 # kiriwrite_page_multimove: Move several pages from one database to another     #
1828 # database.                                                                     #
1829 #                                                                               #
1830 # Usage:                                                                        #
1831 #                                                                               #
1832 # kiriwrite_page_multimove(database, newdatabase, confirm, filelist);           #
1833 #                                                                               #
1834 # database      Specifies the database to move the selected pages from.         #
1835 # newdatabase   Specifies the database to move the selected pages to.           #
1836 # confirm       Confirms the action to move the pages from one database to      #
1837 #               another.                                                        #
1838 # filelist      Specifies the list of pages to move.                            #
1839 #################################################################################
1840
1841         # Get the values that were passed to the subroutine.
1842
1843         my ($database, $newdatabase, $confirm, @filelist) = @_;
1844
1845         # Load the required Perl modules.
1846
1847         use DBI;
1848
1849         # Define a variable for later.
1850
1851         my $pagedata = "";
1852
1853         # Check if the file list is blank and return an error
1854         # if it is.
1855
1856         if (!@filelist){
1857
1858                 # The file list really is blank so return
1859                 # an error.
1860
1861                 kiriwrite_error("nopagesselected");
1862
1863         }
1864
1865         # Check if the file permissions on the original database
1866         # are valid and return an error if they aren't.
1867
1868         my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
1869         my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
1870
1871         if ($database_exists eq 1){
1872
1873                 # The database does not exist, so return an error.
1874
1875                 kiriwrite_error("oldmovedatabasedoesnotexist");
1876
1877         }
1878
1879         if ($database_permissions eq 1){
1880
1881                 # The database permissions are invalid, so return
1882                 # an error.
1883
1884                 kiriwrite_error("oldmovedatabasefileinvalidpermissions");
1885
1886         }
1887
1888         # Check if the confirm value is blank and if it is then
1889         # set the confirm value to 0.
1890
1891         if (!$confirm){
1892
1893                 $confirm = 0;
1894
1895         }
1896
1897         if ($confirm eq 1){
1898
1899                 # The action to move several pages from one database
1900                 # to another has been confirmed.
1901
1902                 # Check if the database that the pages are moving from
1903                 # is the same as the database the pages are moving to.
1904                 # Return an error if it is.
1905
1906                 if ($database eq $newdatabase){
1907
1908                         # The database that the pages are moving from
1909                         # and the database the pages are moving to
1910                         # is the same, so return an error.
1911
1912                         kiriwrite_error("databasemovesame");
1913
1914                 }
1915
1916                 # Check that the new database exists and the permissions
1917                 # for the new database are valid.
1918
1919                 $database_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
1920                 $database_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db', 1, 1, 0);
1921
1922                 if ($database_exists eq 1){
1923
1924                         # The database does not exist, so return an error.
1925
1926                         kiriwrite_error("newmovedatabasedoesnotexist");
1927
1928                 }
1929
1930                 if ($database_permissions eq 1){
1931
1932                         # The database permissions are invalid, so return
1933                         # an error.
1934
1935                         kiriwrite_error("newmovedatabasefileinvalidpermissions");
1936
1937                 }
1938
1939                 # Define some values for later.
1940
1941                 my @olddatabase_info;
1942                 my @olddatabase_page;
1943                 my @newdatabase_info;
1944                 my @newdatabase_page;
1945
1946                 my $filename;
1947                 my $filename_sql;
1948                 my $filename_out;
1949
1950                 my $olddatabase_database_handle;
1951                 my $olddatabase_string_handle;
1952                 my $olddatabase_name;
1953                 my $olddatabase_name_out;
1954                 my $olddatabase_out;
1955                 my $newdatabase_database_handle;
1956                 my $newdatabase_string_handle;
1957                 my $newdatabase_name;
1958                 my $newdatabase_name_out;
1959                 my $newdatabase_out;
1960
1961                 my $warninglist = "";
1962                 my $movedlist = "";
1963
1964                 my $page_filename;
1965                 my $page_filename_sql;
1966                 my $page_filename_out;
1967                 my $page_name;
1968                 my $page_name_sql;
1969                 my $page_name_out;
1970                 my $page_description;
1971                 my $page_description_sql;
1972                 my $page_section;
1973                 my $page_section_sql;
1974                 my $page_template;
1975                 my $page_template_sql;
1976                 my $page_data;
1977                 my $page_data_sql;
1978                 my $page_settings;
1979                 my $page_settings_sql;
1980                 my $page_lastmodified;
1981                 my $page_lastmodified_sql;
1982
1983                 my $page_found = 0;
1984
1985                 # Check if the database filename is valid and return an error if
1986                 # it isn't.
1987
1988                 my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
1989
1990                 if ($newpagedatabase_filename_check eq 1){
1991
1992                         # The database filename is blank, so return an error.
1993
1994                         kiriwrite_error("blankdatabasepageadd");
1995
1996                 } elsif ($newpagedatabase_filename_check eq 2){
1997
1998                         # The database filename is invalid, so return an error.
1999
2000                         kiriwrite_error("databasefilenameinvalid");
2001
2002                 }
2003
2004                 # Load the old and new SQLite databases.
2005
2006                 $olddatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
2007                 $newdatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
2008
2009                 # Get the database information from both databases.
2010
2011                 $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("oldmovedatabasefileinvalid");
2012                 $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("newmovedatabasefileinvalid");
2013                 $olddatabase_string_handle->execute();
2014                 $newdatabase_string_handle->execute();
2015
2016                 @olddatabase_info       = $olddatabase_string_handle->fetchrow_array();
2017                 @newdatabase_info       = $newdatabase_string_handle->fetchrow_array();
2018
2019                 $olddatabase_name       = $olddatabase_info[0];
2020                 $newdatabase_name       = $newdatabase_info[0];
2021
2022                 # Convert the database names so that they can be displayed
2023                 # properly.
2024
2025                 $olddatabase_name_out   = kiriwrite_convert($olddatabase_name, "normal_display");
2026                 $newdatabase_name_out   = kiriwrite_convert($newdatabase_name, "normal_display");
2027                 $olddatabase_out        = kiriwrite_convert($database, "normal_display");
2028                 $newdatabase_out        = kiriwrite_convert($newdatabase, "normal_display");
2029
2030                 # Get each file in the old database, get the file values,
2031                 # put them into the new database and delete the pages
2032                 # from the old database.
2033
2034                 foreach $filename (@filelist){
2035
2036                         # Check if the filename exists in the old database.
2037                         # If the filename does not exist then write
2038                         # a warning and process the next file.
2039
2040                         $filename_sql                   = kiriwrite_convert($filename, "kiriwrite");
2041                         $filename_out                   = kiriwrite_convert($filename, "normal_display");
2042                         $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
2043                         $olddatabase_string_handle->execute();
2044
2045                         $page_found = 0;
2046
2047                         while (@olddatabase_page = $olddatabase_string_handle->fetchrow_array()){
2048
2049                                 # The page in the old database does exist so
2050                                 # set the value to 1.
2051
2052                                 $page_found = 1;
2053
2054                         }
2055
2056                         # See if the page was found and write a warning if it
2057                         # wasn't.
2058
2059                         if ($page_found eq 0){
2060
2061                                 # The page was not found. Write a warning and
2062                                 # process the next page.
2063
2064                                 $filename_out   = kiriwrite_convert($filename, "normal_display");
2065                                 $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' could not be found in the '" . $olddatabase_name_out . "' database. Page skipped.<br>";
2066                                 next;
2067
2068                         }
2069
2070                         # Check if the filename exists in the new database.
2071                         # If the filename does exist then write
2072                         # a warning and process the next file.
2073
2074                         $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
2075                         $newdatabase_string_handle->execute();
2076
2077                         $page_found = 0;
2078
2079                         while (@newdatabase_page = $newdatabase_string_handle->fetchrow_array()){
2080
2081                                 # The page in the old database does exist so
2082                                 # set the value to 1.
2083
2084                                 $page_found = 1;
2085
2086                         }
2087
2088                         # See if the page was found and write a warning if it
2089                         # wasn't.
2090
2091                         if ($page_found eq 1){
2092
2093                                 # The page was not found. Write a warning and
2094                                 # process the next page.
2095
2096                                 $filename_out   = kiriwrite_convert($filename, "normal_display");
2097                                 $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' already exists in '" . $olddatabase_name_out . "' database. Page skipped.<br>";
2098                                 next;
2099
2100                         }
2101
2102
2103                         # Get the information about the page.
2104
2105                         $olddatabase_string_handle->execute();
2106                         @olddatabase_page       = $olddatabase_string_handle->fetchrow_array();
2107                         $page_filename          = $olddatabase_page[0];
2108                         $page_name              = $olddatabase_page[1];
2109                         $page_description       = $olddatabase_page[2];
2110                         $page_section           = $olddatabase_page[3];
2111                         $page_template          = $olddatabase_page[4];
2112                         $page_data              = $olddatabase_page[5];
2113                         $page_settings          = $olddatabase_page[6];
2114                         $page_lastmodified      = $olddatabase_page[7];
2115
2116                         # Convert the values so that they can be processed
2117                         # properly.
2118
2119                         $page_filename_sql      = kiriwrite_convert($page_filename, "kiriwrite");
2120                         $page_name_sql          = kiriwrite_convert($page_name, "kiriwrite");
2121                         $page_description_sql   = kiriwrite_convert($page_description, "kiriwrite");
2122                         $page_section_sql       = kiriwrite_convert($page_section, "kiriwrite");
2123                         $page_template_sql      = kiriwrite_convert($page_template, "kiriwrite");
2124                         $page_data_sql          = kiriwrite_convert($page_data, "kiriwrite");
2125                         $page_settings_sql      = kiriwrite_convert($page_settings, "kiriwrite");
2126                         $page_lastmodified_sql  = kiriwrite_convert($page_lastmodified, "kiriwrite");
2127
2128                         $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
2129                         $page_name_out          = kiriwrite_convert($page_name, "normal_display");
2130
2131                         # Add the page to the new database.
2132
2133                         $newdatabase_string_handle      = $newdatabase_database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
2134                                 \'' . $page_filename_sql . '\',
2135                                 \'' . $page_name_sql . '\',
2136                                 \'' . $page_description_sql . '\',
2137                                 \'' . $page_section_sql . '\',
2138                                 \'' . $page_template_sql . '\',
2139                                 \'' . $page_data_sql . '\',
2140                                 \'' . $page_settings_sql . '\',
2141                                 \'' . $page_lastmodified_sql . '\'
2142                         )');
2143                         $newdatabase_string_handle->execute();
2144
2145                         # Delete the page from the old database.
2146
2147                         $olddatabase_string_handle      = $olddatabase_database_handle->prepare('DELETE FROM kiriwrite_database_pages WHERE filename = \'' . $filename_sql . '\'');
2148                         $olddatabase_string_handle->execute();
2149
2150                         # Append the moved page (filename and name) to the list of
2151                         # moved pages.
2152
2153                         if (!$page_name_out){
2154
2155                                 $page_name_out = "<i>No Name</i>";
2156
2157                         }
2158
2159                         $movedlist = $movedlist . $page_name_out . " (" . $filename_out . ")" . "<br>";
2160
2161                 }
2162
2163                 # Write out a message saying that the pages were moved (if any)
2164                 # to the new database (and any warnings given).
2165
2166                 $pagedata = $pagedata . "<h2>Move multiple pages</h2>";
2167
2168                 if ($movedlist){
2169
2170                 $pagedata = $pagedata . "The following pages from the '" . $olddatabase_name_out . "' database were moved to the '" . $newdatabase_name_out . "' database:<br><br>";
2171                 $pagedata = $pagedata . "<div class=\"datalist\">";
2172                 $pagedata = $pagedata . $movedlist;
2173                 $pagedata = $pagedata . "</div><br><br>";
2174
2175                 } else {
2176
2177                         $pagedata = $pagedata . "No pages were moved from the '" . $olddatabase_name_out  . "' database to the '" . $newdatabase_name_out . "' database.<br><br>";
2178
2179                 }
2180
2181                 if ($warninglist){
2182
2183                         $pagedata = $pagedata . "The following errors/warnings have occured while moving the pages:<br><br>";
2184                         $pagedata = $pagedata . "<div class=\"datalist\">";
2185                         $pagedata = $pagedata . $warninglist;
2186                         $pagedata = $pagedata . "</div><br><br>";
2187
2188                 }
2189
2190                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $olddatabase_out . "\">Return to the page list for the '" . $olddatabase_name_out . "' database.</a> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $newdatabase_out . "\">View the page list for the '" . $newdatabase_name_out . "' database.</a>";
2191
2192                 return $pagedata;
2193
2194         } elsif ($confirm eq 0) {
2195
2196                 # The action to move several pages from one database
2197                 # to another has not been confirmed so write a form.
2198
2199                 # Load the SQLite database and get the needed
2200                 # information about the database.
2201
2202                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
2203                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
2204                 $string_handle->execute();
2205
2206                 my @database_info       = $string_handle->fetchrow_array();
2207                 my $database_name       = $database_info[0];
2208
2209                 # Define some values for later.
2210
2211                 my $database_info;
2212                 my @page_info;
2213                 my @pagenames;
2214                 my @filenames;
2215                 my $data_file;
2216                 my $data_file_length;
2217                 my $database_list;
2218                 my $database_filename;
2219                 my $filename;
2220                 my $filename_out;
2221                 my $filelist_filename_sql;
2222                 my $filelist_filename;
2223                 my $pagelist_formdata;
2224                 my $newdatabase_filename;
2225                 my $newdatabase_filename_out;
2226                 my $newdatabase_name;
2227                 my $newdatabase_name_out;
2228                 my $pagelist;
2229                 my $pagename;
2230                 my $pageseek    = 0;
2231                 my $dbseek      = 0;
2232                 my $pagefound   = 0;
2233
2234                 # Process each filename given.
2235
2236                 foreach $filelist_filename (@filelist){
2237
2238                         $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
2239                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
2240
2241                         $string_handle->execute();
2242
2243                         # Check if the filename given exists and if it
2244                         # doesn't then skip this filename and go onto
2245                         # the next filename.
2246
2247                         while (@page_info = $string_handle->fetchrow_array()){
2248
2249                                 $pagefound = 1;
2250
2251                         }
2252
2253                         if ($pagefound eq 0){
2254
2255                                 next;
2256
2257                         }
2258
2259                         # Get the data again.
2260
2261                         $string_handle->execute();
2262                         @page_info      = $string_handle->fetchrow_array();
2263
2264                         # Add the page name and file name to their seperate
2265                         # arrays.
2266
2267                         $pagenames[$pageseek]   = $page_info[1];
2268                         $filenames[$pageseek]   = $page_info[0];
2269
2270                         # Increment the page seek counter and reset the
2271                         # page found value.
2272
2273                         $pageseek++;
2274                         $pagefound = 0;
2275
2276                 }
2277
2278                 # Check if any pages exust and return an error if
2279                 # there wasn't.
2280
2281                 if ($pageseek eq 0){
2282
2283                         # None of the selected pages exist, so return
2284                         # an error.
2285
2286                         kiriwrite_error("nopagesselected");
2287
2288                 }
2289
2290                 # Create the page list of files to move.
2291
2292                 $pageseek               = 1;
2293                 $pagelist               = "";
2294                 $pagelist_formdata      = "";
2295
2296                 foreach $filename (@filenames){
2297
2298
2299
2300                         $pagename       = $pagenames[$pageseek - 1];
2301
2302                         # Check if the page name is blank and if it is then say
2303                         # no name.
2304
2305                         if (!$pagename){
2306
2307                                 # The page name is blank.
2308
2309                                 $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $filename . ")<br>";
2310
2311                         } else {
2312
2313                                 # Append the page name and filename to the page list.
2314
2315                                 $pagelist       = $pagelist . kiriwrite_convert($pagename, "normal_display") . " (" . $filename . ")<br>";
2316
2317                         }
2318
2319                         # Append the form data to the page list form data.
2320
2321                         $filename_out           = kiriwrite_convert($filename, "normal_display");
2322
2323                         $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
2324                         $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filename . "\">";
2325
2326                         $pageseek++;
2327
2328                 }
2329
2330                 # Get the database filenames and names.
2331
2332                 # Check the directory to make sure the permissions are settings are valid
2333                 # and return an error if the permission settings are invalid.
2334
2335                 my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
2336
2337                 if ($data_directory_permissions eq 1){
2338
2339                         # The data directory has invalid permissions set, so return an error.
2340
2341                         kiriwrite_error("datadirectoryinvalidpermissions");
2342
2343                 }
2344
2345                 # Open the directory and get the list of all files ending with .xml and
2346                 # put them into the data_directory array.
2347
2348                 opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
2349                 my @data_directory = grep /m*\.db/, readdir(DATADIR);
2350                 closedir(DATADIR);
2351
2352                 # Process each database to get the database name.
2353
2354                 $database_list = "<select name=\"newdatabase\">";
2355
2356                 foreach $data_file (@data_directory){
2357
2358                         # Get the length of the filename.
2359
2360                         $data_file_length       = length($data_file);
2361
2362                         # Remove the last three characters from the filename.
2363
2364                         $data_file              = substr($data_file, 0, $data_file_length - 3);
2365
2366                         # Check if the permissions are valid before trying
2367                         # to load the database.
2368
2369                         $database_filename      = $kiriwrite_config{"directory_data_db"} . '/' . $data_file . '.db';
2370                         $database_permissions   = kiriwrite_filepermissions($database_filename, 1, 0, 0);
2371
2372                         if ($database_permissions eq 1){
2373
2374                                 # If the database has invalid permissions set then
2375                                 # process the next database.
2376
2377                                 next;
2378
2379                         }
2380
2381                         # Load the SQLite database.
2382
2383                         $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
2384
2385                         # Query the SQLite database or return an error (meaning that the database is in
2386                         # a invalid format), if it can't then process the next database.
2387
2388                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
2389
2390                         $string_handle->execute();
2391                         @database_info = $string_handle->fetchrow_array();
2392
2393                         # Get the values from the query.
2394
2395                         $newdatabase_name       = $database_info[0];
2396
2397                         # Convert the values so that they can be displayed
2398                         # properly.
2399
2400                         $newdatabase_filename_out       = kiriwrite_convert($data_file, "normal_display");
2401                         $newdatabase_name_out           = kiriwrite_convert($newdatabase_name, "normal_display");
2402
2403                         # Append the database filename and name to the list of databases
2404                         # to move the pages to.
2405
2406                         $database_list = $database_list . "<option value=\"" . $newdatabase_filename_out . "\">" . $newdatabase_name_out . "</option>";
2407
2408                 }
2409
2410                 $database_list = $database_list . "</select>";
2411
2412                 # Convert some values so that they display properly.
2413
2414                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
2415                 my $database_out        = kiriwrite_convert($database, "normal_display");
2416
2417                 # Write out the form.
2418
2419                 $pagedata = "<h2>Move selected pages</h2>";
2420                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
2421                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
2422                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multimove\">";
2423                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
2424                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
2425                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
2426                 $pagedata = $pagedata . $pagelist_formdata;
2427                 $pagedata = $pagedata . "Which database do you want to move the following pages from the '" . $database_name_out . "' database to?<br><br>";
2428                 $pagedata = $pagedata . "<div class=\"datalist\">";
2429                 $pagedata = $pagedata . $pagelist;
2430                 $pagedata = $pagedata . "</div><br>";
2431                 $pagedata = $pagedata . "Move pages to: " . $database_list . "<br><br>";
2432                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Move pages to the selected database.\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
2433                 $pagedata = $pagedata . "</form>";
2434
2435                 return $pagedata;
2436
2437         } else {
2438
2439                 # The confirm value is other than 0 or 1, so return
2440                 # an error.
2441
2442                 kiriwrite_error("invalidvariable");
2443
2444         }
2445
2446
2447 }
2448
2449
2450 sub kiriwrite_page_multicopy{
2451 #################################################################################
2452 # kiriwrite_page_multicopy: Copy several pages from one database to another     #
2453 # database.                                                                     #
2454 #                                                                               #
2455 # Usage:                                                                        #
2456 #                                                                               #
2457 # kiriwrite_page_multicopy(database, newdatabase, confirm, filelist);           #
2458 #                                                                               #
2459 # database      Specifies the database to copy the selected pages from.         #
2460 # newdatabase   Specifies the database to copy the selected page to.            #
2461 # confirm       Confirms the action to copy the pages.                          #
2462 # filelist      A list of filenames to copy in an array.                        #
2463 #################################################################################
2464
2465         # Get the values that were passed to the subroutine.
2466
2467         my ($database, $newdatabase, $confirm, @filelist) = @_;
2468
2469         # Load the required Perl modules.
2470
2471         use DBI;
2472
2473         # Define a variable for later.
2474
2475         my $pagedata = "";
2476
2477         # Check if the file list is blank and return an error
2478         # if it is.
2479
2480         if (!@filelist){
2481
2482                 # The file list really is blank so return
2483                 # an error.
2484
2485                 kiriwrite_error("nopagesselected");
2486
2487         }
2488
2489         # Check if the file permissions on the original database
2490         # are valid and return an error if they aren't.
2491
2492         my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
2493         my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 0);
2494
2495         if ($database_exists eq 1){
2496
2497                 # The database does not exist, so return an error.
2498
2499                 kiriwrite_error("oldcopydatabasedoesnotexist");
2500
2501         }
2502
2503         if ($database_permissions eq 1){
2504
2505                 # The database permissions are invalid, so return
2506                 # an error.
2507
2508                 kiriwrite_error("oldcopydatabasefilenameinvalidpermissions");
2509
2510         }
2511
2512         # Check if the confirm value is blank and if it is then
2513         # set the confirm value to 0.
2514
2515         if (!$confirm){
2516
2517                 $confirm = 0;
2518
2519         }
2520
2521         # Check if the database filename is valid and return an error if
2522         # it isn't.
2523
2524         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
2525
2526         if ($pagedatabase_filename_check eq 1){
2527
2528                 # The database filename is blank, so return an error.
2529
2530                 kiriwrite_error("blankdatabasepageadd");
2531
2532         } elsif ($pagedatabase_filename_check eq 2){
2533
2534                 # The database filename is invalid, so return an error.
2535
2536                 kiriwrite_error("databasefilenameinvalid");
2537
2538         }
2539
2540         if ($confirm eq 1){
2541
2542                 # The action to copy several pages from one database
2543                 # to another has been confirmed.
2544
2545                 # Check if the database that the pages are copied from
2546                 # is the same as the database the pages are copied to.
2547                 # Return an error if it is.
2548
2549                 if ($database eq $newdatabase){
2550
2551                         # The database that the pages are being copied from
2552                         # and the database that the pages are copied to
2553                         # is the same, so return an error.
2554
2555                         kiriwrite_error("databasecopysame");
2556
2557                 }
2558
2559                 # Check that the new database exists and the permissions
2560                 # for the new database are valid.
2561
2562                 $database_exists                = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
2563                 $database_permissions           = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db', 1, 1, 0);
2564
2565                 if ($database_exists eq 1){
2566
2567                         # The database does not exist, so return an error.
2568
2569                         kiriwrite_error("newcopydatabasedoesnotexist");
2570
2571                 }
2572
2573                 if ($database_permissions eq 1){
2574
2575                         # The database permissions are invalid, so return
2576                         # an error.
2577
2578                         kiriwrite_error("newcopydatabasefileinvalidpermissions");
2579
2580                 }
2581
2582                 # Define some values for later.
2583
2584                 my @olddatabase_info;
2585                 my @olddatabase_page;
2586                 my @newdatabase_info;
2587                 my @newdatabase_page;
2588
2589                 my $filename;
2590                 my $filename_sql;
2591                 my $filename_out;
2592
2593                 my $olddatabase_database_handle;
2594                 my $olddatabase_string_handle;
2595                 my $olddatabase_name;
2596                 my $olddatabase_name_out;
2597                 my $olddatabase_out;
2598                 my $newdatabase_database_handle;
2599                 my $newdatabase_string_handle;
2600                 my $newdatabase_name;
2601                 my $newdatabase_name_out;
2602                 my $newdatabase_out;
2603
2604                 my $warninglist = "";
2605                 my $copiedlist = "";
2606
2607                 my $page_filename;
2608                 my $page_filename_sql;
2609                 my $page_filename_out;
2610                 my $page_name;
2611                 my $page_name_sql;
2612                 my $page_name_out;
2613                 my $page_description;
2614                 my $page_description_sql;
2615                 my $page_section;
2616                 my $page_section_sql;
2617                 my $page_template;
2618                 my $page_template_sql;
2619                 my $page_data;
2620                 my $page_data_sql;
2621                 my $page_settings;
2622                 my $page_settings_sql;
2623                 my $page_lastmodified;
2624                 my $page_lastmodified_sql;
2625
2626                 my $page_found = 0;
2627
2628                 # Check if the database filename is valid and return an error if
2629                 # it isn't.
2630
2631                 my $newpagedatabase_filename_check = kiriwrite_variablecheck($newdatabase, "filename", 0, 1);
2632
2633                 if ($newpagedatabase_filename_check eq 1){
2634
2635                         # The database filename is blank, so return an error.
2636
2637                         kiriwrite_error("blankdatabasepageadd");
2638
2639                 } elsif ($newpagedatabase_filename_check eq 2){
2640
2641                         # The database filename is invalid, so return an error.
2642
2643                         kiriwrite_error("databasefilenameinvalid");
2644
2645                 }
2646
2647                 # Load the old and new SQLite databases.
2648
2649                 $olddatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
2650                 $newdatabase_database_handle    = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $newdatabase . '.db');
2651
2652                 # Get the database information from both databases.
2653
2654                 $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("oldcopydatabasefileinvalid");
2655                 $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("newcopydatabasefileinvalid");
2656                 $olddatabase_string_handle->execute();
2657                 $newdatabase_string_handle->execute();
2658
2659                 @olddatabase_info       = $olddatabase_string_handle->fetchrow_array();
2660                 @newdatabase_info       = $newdatabase_string_handle->fetchrow_array();
2661
2662                 $olddatabase_name       = $olddatabase_info[0];
2663                 $newdatabase_name       = $newdatabase_info[0];
2664
2665                 # Convert the database names so that they can be displayed
2666                 # properly.
2667
2668                 $olddatabase_name_out   = kiriwrite_convert($olddatabase_name, "normal_display");
2669                 $newdatabase_name_out   = kiriwrite_convert($newdatabase_name, "normal_display");
2670                 $olddatabase_out        = kiriwrite_convert($database, "normal_display");
2671                 $newdatabase_out        = kiriwrite_convert($newdatabase, "normal_display");
2672
2673                 # Get each file in the old database, get the file values,
2674                 # put them into the new database.
2675
2676                 foreach $filename (@filelist){
2677
2678                         # Check if the filename exists in the old database.
2679                         # If the filename does not exist then write
2680                         # a warning and process the next file.
2681
2682                         $filename_sql                   = kiriwrite_convert($filename, "kiriwrite");
2683                         $filename_out                   = kiriwrite_convert($filename, "normal_display");
2684                         $olddatabase_string_handle      = $olddatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
2685                         $olddatabase_string_handle->execute();
2686
2687                         $page_found = 0;
2688
2689                         while (@olddatabase_page = $olddatabase_string_handle->fetchrow_array()){
2690
2691                                 # The page in the old database does exist so
2692                                 # set the value to 1.
2693
2694                                 $page_found = 1;
2695
2696                         }
2697
2698                         # See if the page was found and write a warning if it
2699                         # wasn't.
2700
2701                         if ($page_found eq 0){
2702
2703                                 # The page was not found. Write a warning and
2704                                 # process the next page.
2705
2706                                 $filename_out   = kiriwrite_convert($filename, "normal_display");
2707                                 $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' could not be found in the '" . $olddatabase_name_out . "' database. Page skipped.<br>";
2708                                 next;
2709
2710                         }
2711
2712                         # Check if the filename exists in the new database.
2713                         # If the filename does exist then write
2714                         # a warning and process the next file.
2715
2716                         $newdatabase_string_handle      = $newdatabase_database_handle->prepare('SELECT * FROM kiriwrite_database_pages where filename = \'' . $filename_sql . '\' LIMIT 1');
2717                         $newdatabase_string_handle->execute();
2718
2719                         $page_found = 0;
2720
2721                         while (@newdatabase_page = $newdatabase_string_handle->fetchrow_array()){
2722
2723                                 # The page in the old database does exist so
2724                                 # set the value to 1.
2725
2726                                 $page_found = 1;
2727
2728                         }
2729
2730                         # See if the page was found and write a warning if it
2731                         # wasn't.
2732
2733                         if ($page_found eq 1){
2734
2735                                 # The page was not found. Write a warning and
2736                                 # process the next page.
2737
2738                                 $filename_out   = kiriwrite_convert($filename, "normal_display");
2739                                 $warninglist    = $warninglist . "The page with the filename '" . $filename_out . "' already exists in '" . $newdatabase_name_out . "' database. Page skipped.<br>";
2740                                 next;
2741
2742                         }
2743
2744
2745                         # Get the information about the page.
2746
2747                         $olddatabase_string_handle->execute();
2748                         @olddatabase_page       = $olddatabase_string_handle->fetchrow_array();
2749                         $page_filename          = $olddatabase_page[0];
2750                         $page_name              = $olddatabase_page[1];
2751                         $page_description       = $olddatabase_page[2];
2752                         $page_section           = $olddatabase_page[3];
2753                         $page_template          = $olddatabase_page[4];
2754                         $page_data              = $olddatabase_page[5];
2755                         $page_settings          = $olddatabase_page[6];
2756                         $page_lastmodified      = $olddatabase_page[7];
2757
2758                         # Convert the values so that they can be processed
2759                         # properly.
2760
2761                         $page_filename_sql      = kiriwrite_convert($page_filename, "kiriwrite");
2762                         $page_name_sql          = kiriwrite_convert($page_name, "kiriwrite");
2763                         $page_description_sql   = kiriwrite_convert($page_description, "kiriwrite");
2764                         $page_section_sql       = kiriwrite_convert($page_section, "kiriwrite");
2765                         $page_template_sql      = kiriwrite_convert($page_template, "kiriwrite");
2766                         $page_data_sql          = kiriwrite_convert($page_data, "kiriwrite");
2767                         $page_settings_sql      = kiriwrite_convert($page_settings, "kiriwrite");
2768                         $page_lastmodified_sql  = kiriwrite_convert($page_lastmodified, "kiriwrite");
2769
2770                         $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
2771                         $page_name_out          = kiriwrite_convert($page_name, "normal_display");
2772
2773                         # Add the page to the new database.
2774
2775                         $newdatabase_string_handle      = $newdatabase_database_handle->prepare('INSERT INTO kiriwrite_database_pages VALUES(
2776                                 \'' . $page_filename_sql . '\',
2777                                 \'' . $page_name_sql . '\',
2778                                 \'' . $page_description_sql . '\',
2779                                 \'' . $page_section_sql . '\',
2780                                 \'' . $page_template_sql . '\',
2781                                 \'' . $page_data_sql . '\',
2782                                 \'' . $page_settings_sql . '\',
2783                                 \'' . $page_lastmodified_sql . '\'
2784                         )');
2785                         $newdatabase_string_handle->execute();
2786
2787                         # Append the copied page (filename and name) to the list of
2788                         # copied pages.
2789
2790                         if (!$page_name_out){
2791
2792                                 $page_name_out = "<i>No page name</i>";
2793
2794                         }
2795
2796                         $copiedlist = $copiedlist . $page_name_out . " (" . $filename_out . ")" . "<br>";
2797
2798                 }
2799
2800                 # Write out a message saying that the pages were moved (if any)
2801                 # to the new database (and any warnings given).
2802
2803                 $pagedata = $pagedata . "<h2>Copy multiple pages</h2>";
2804
2805                 if ($copiedlist){
2806
2807                 $pagedata = $pagedata . "The following pages from the '" . $olddatabase_name_out . "' database were copied to the '" . $newdatabase_name_out . "' database:<br><br>";
2808                 $pagedata = $pagedata . "<div class=\"datalist\">";
2809                 $pagedata = $pagedata . $copiedlist;
2810                 $pagedata = $pagedata . "</div><br><br>";
2811
2812                 } else {
2813
2814                         $pagedata = $pagedata . "No pages were copied from the '" . $olddatabase_name_out  . "' database to the '" . $newdatabase_name_out . "' database.<br><br>";
2815
2816                 }
2817
2818                 if ($warninglist){
2819
2820                         $pagedata = $pagedata . "The following errors/warnings have occured while copying the pages:<br><br>";
2821                         $pagedata = $pagedata . "<div class=\"datalist\">";
2822                         $pagedata = $pagedata . $warninglist;
2823                         $pagedata = $pagedata . "</div><br><br>";
2824
2825                 }
2826
2827                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $olddatabase_out . "\">Return to the page list for the '" . $olddatabase_name_out . "' database.</a> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $newdatabase_out . "\">View the page list for the '" . $newdatabase_name_out . "' database.</a>";
2828
2829                 return $pagedata;
2830
2831         } elsif ($confirm eq 0) {
2832
2833                 # The action to copy several pages from one database
2834                 # to another has not been confirmed so write a form.
2835
2836                 # Load the SQLite database and get the needed
2837                 # information about the database.
2838
2839                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
2840                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
2841                 $string_handle->execute();
2842
2843                 my @database_info       = $string_handle->fetchrow_array();
2844                 my $database_name       = $database_info[0];
2845
2846                 # Define some values for later.
2847
2848                 my $database_info;
2849                 my @page_info;
2850                 my @pagenames;
2851                 my @filenames;
2852                 my $data_file;
2853                 my $data_file_length;
2854                 my $database_list;
2855                 my $database_filename;
2856                 my $filename;
2857                 my $filename_out;
2858                 my $filelist_filename_sql;
2859                 my $filelist_filename;
2860                 my $pagelist_formdata;
2861                 my $newdatabase_filename;
2862                 my $newdatabase_filename_out;
2863                 my $newdatabase_name;
2864                 my $newdatabase_name_out;
2865                 my $pagelist;
2866                 my $pagename;
2867                 my $pageseek    = 0;
2868                 my $dbseek      = 0;
2869                 my $pagefound   = 0;
2870
2871                 # Process each filename given.
2872
2873                 foreach $filelist_filename (@filelist){
2874
2875                         $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
2876                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
2877
2878                         $string_handle->execute();
2879
2880                         # Check if the filename given exists and if it
2881                         # doesn't then skip this filename and go onto
2882                         # the next filename.
2883
2884                         while (@page_info = $string_handle->fetchrow_array()){
2885
2886                                 $pagefound = 1;
2887
2888                         }
2889
2890                         if ($pagefound eq 0){
2891
2892                                 next;
2893
2894                         }
2895
2896                         # Get the data again.
2897
2898                         $string_handle->execute();
2899                         @page_info      = $string_handle->fetchrow_array();
2900
2901                         # Add the page name and file name to their seperate
2902                         # arrays.
2903
2904                         $pagenames[$pageseek]   = $page_info[1];
2905                         $filenames[$pageseek]   = $page_info[0];
2906
2907                         # Increment the page seek counter and reset the
2908                         # page found value.
2909
2910                         $pageseek++;
2911                         $pagefound = 0;
2912
2913                 }
2914
2915                 # Check if any pages exust and return an error if
2916                 # there wasn't.
2917
2918                 if ($pageseek eq 0){
2919
2920                         # None of the selected pages exist, so return
2921                         # an error.
2922
2923                         kiriwrite_error("nopagesselected");
2924
2925                 }
2926
2927                 # Create the page list of files to move.
2928
2929                 $pageseek               = 1;
2930                 $pagelist               = "";
2931                 $pagelist_formdata      = "";
2932
2933                 foreach $filename (@filenames){
2934
2935                         $pagename       = $pagenames[$pageseek - 1];
2936
2937                         # Check if the
2938
2939                         if (!$pagename){
2940
2941                                 # Write a message saying that there is no page name.
2942
2943                                 $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $filename . ")<br>";
2944
2945                         } else {
2946
2947                                 # Append the page name and filename to the page list.
2948
2949                                 $pagelist       = $pagelist . $pagename . " (" . $filename . ")<br>";
2950
2951                         }
2952
2953
2954
2955                         # Append the form data to the page list form data.
2956
2957                         $filename_out           = kiriwrite_convert($filename, "normal_display");
2958
2959                         $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"name[" . $pageseek . "]\" value=\"on\">";
2960                         $pagelist_formdata      = $pagelist_formdata . "<input type=\"hidden\" name=\"id[" . $pageseek . "]\" value=\"" . $filename . "\">";
2961
2962                         $pageseek++;
2963
2964                 }
2965
2966                 # Get the database filenames and names.
2967
2968                 # Check the directory to make sure the permissions are settings are valid
2969                 # and return an error if the permission settings are invalid.
2970
2971                 my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
2972
2973                 if ($data_directory_permissions eq 1){
2974
2975                         # The data directory has invalid permissions set, so return an error.
2976
2977                         kiriwrite_error("datadirectoryinvalidpermissions");
2978
2979                 }
2980
2981                 # Open the directory and get the list of all files ending with .xml and
2982                 # put them into the data_directory array.
2983
2984                 opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
2985                 my @data_directory = grep /m*\.db/, readdir(DATADIR);
2986                 closedir(DATADIR);
2987
2988                 # Process each database to get the database name.
2989
2990                 $database_list = "<select name=\"newdatabase\">";
2991
2992                 foreach $data_file (@data_directory){
2993
2994                         # Get the length of the filename.
2995
2996                         $data_file_length       = length($data_file);
2997
2998                         # Remove the last three characters from the filename.
2999
3000                         $data_file              = substr($data_file, 0, $data_file_length - 3);
3001
3002                         # Check if the permissions are valid before trying
3003                         # to load the database.
3004
3005                         $database_filename      = $kiriwrite_config{"directory_data_db"} . '/' . $data_file . '.db';
3006                         $database_permissions   = kiriwrite_filepermissions($database_filename, 1, 0, 0);
3007
3008                         if ($database_permissions eq 1){
3009
3010                                 # If the database has invalid permissions set then
3011                                 # process the next database.
3012
3013                                 next;
3014
3015                         }
3016
3017                         # Load the SQLite database.
3018
3019                         $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
3020
3021                         # Query the SQLite database or return an error (meaning that the database is in
3022                         # a invalid format), if it can't then process the next database.
3023
3024                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
3025
3026                         $string_handle->execute();
3027                         @database_info = $string_handle->fetchrow_array();
3028
3029                         # Get the values from the query.
3030
3031                         $newdatabase_name       = $database_info[0];
3032
3033                         # Convert the values so that they can be displayed
3034                         # properly.
3035
3036                         $newdatabase_filename_out       = kiriwrite_convert($data_file, "normal_display");
3037                         $newdatabase_name_out           = kiriwrite_convert($newdatabase_name, "normal_display");
3038
3039                         # Append the database filename and name to the list of databases
3040                         # to move the pages to.
3041
3042                         $database_list = $database_list . "<option value=\"" . $newdatabase_filename_out . "\">" . $newdatabase_name_out . "</option>";
3043
3044                 }
3045
3046                 $database_list = $database_list . "</select>";
3047
3048                 # Convert some values so that they display properly.
3049
3050                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
3051                 my $database_out        = kiriwrite_convert($database, "normal_display");
3052
3053                 # Write out the form.
3054
3055                 $pagedata = "<h2>Copy selected pages</h2>";
3056                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
3057                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
3058                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multicopy\">";
3059                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
3060                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
3061                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
3062                 $pagedata = $pagedata . $pagelist_formdata;
3063                 $pagedata = $pagedata . "Which database do you want to copy the following pages from the '" . $database_name_out . "' database to?<br><br>";
3064                 $pagedata = $pagedata . "<div class=\"datalist\">";
3065                 $pagedata = $pagedata . $pagelist;
3066                 $pagedata = $pagedata . "</div><br>";
3067                 $pagedata = $pagedata . "Copy pages to: " . $database_list . "<br><br>";
3068                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Copy pages to the selected database.\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
3069                 $pagedata = $pagedata . "</form>";
3070
3071                 return $pagedata;
3072
3073         } else {
3074
3075                 # The confirm value is other than 0 or 1, so return
3076                 # an error.
3077
3078                 kiriwrite_error("invalidvariable");
3079
3080         }
3081
3082 }
3083
3084 sub kiriwrite_page_multiedit{
3085 #################################################################################
3086 # kiriwrite_page_multiedit: Edit several pages from a database.                 #
3087 #                                                                               #
3088 # Usage:                                                                        #
3089 #                                                                               #
3090 # kiriwrite_page_multiedit(database, newsection, altersection, newtemplate,     #
3091 #                               altertemplate, newsettings, altersettings       #
3092 #                               confirm, filelist);                             #
3093 #                                                                               #
3094 # database      Specifies the database to edit the pages from.                  #
3095 # newsection    Specifies the new section name to use on the selected pages.    #
3096 # altersection  Specifies if the section name should be altered.                #
3097 # newtemplate   Specifies the new template filename to use on the selected      #
3098 #               pages.                                                          #
3099 # altertemplate Specifies if the template filename should be altered.           #
3100 # newsettings   Specifies the new settings to use on the selected pages.        #
3101 # altersettings Specifies if the settings should be altered.                    #
3102 # confirm       Confirms the action to edit the selected pages.                 #
3103 # filelist      The list of file names to edit.                                 #
3104 #################################################################################
3105
3106         # Get the values that were passed to the subroutine.
3107
3108         my ($database, $newsection, $altersection, $newtemplate, $altertemplate, $newsettings, $altersettings, $confirm, @filelist) = @_;
3109
3110         # Load the required Perl modules.
3111
3112         use DBI;
3113
3114         # Define a variable for later.
3115
3116         my $pagedata = "";
3117
3118         # Check if the file list is blank and return an error
3119         # if it is.
3120
3121         if (!@filelist){
3122
3123                 # The file list really is blank so return
3124                 # an error.
3125
3126                 kiriwrite_error("nopagesselected");
3127
3128         }
3129
3130         # Check if the file permissions on the original database
3131         # are valid and return an error if they aren't.
3132
3133         my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
3134         my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 1, 0);
3135
3136         if ($database_exists eq 1){
3137
3138                 # The database does not exist, so return an error.
3139
3140                 kiriwrite_error("databasemissingfile");
3141
3142         }
3143
3144         if ($database_permissions eq 1){
3145
3146                 # The database permissions are invalid, so return
3147                 # an error.
3148
3149                 kiriwrite_error("databaseinvalidpermissions");
3150
3151         }
3152
3153         # Check if certain values are undefined and define them if
3154         # they are.
3155
3156         if (!$altersection){
3157
3158                 # The alter section value is blank, so set it to
3159                 # off.
3160
3161                 $altersection   = "off";
3162
3163         }
3164
3165         if (!$altertemplate){
3166
3167                 # The alter template value is blank, so set it to
3168                 # off.
3169
3170                 $altertemplate  = "off";
3171
3172         }
3173
3174         if (!$altersettings){
3175
3176                 # The alter settings value is blank, so set it to
3177                 # off.
3178
3179                 $altersettings  = "off";
3180
3181         }
3182
3183         # Check if the database filename is valid and return an error if
3184         # it isn't.
3185
3186         my $pagedatabase_filename_check = kiriwrite_variablecheck($database, "filename", 0, 1);
3187
3188         if ($pagedatabase_filename_check eq 1){
3189
3190                 # The database filename is blank, so return an error.
3191
3192                 kiriwrite_error("blankdatabasepageadd");
3193
3194         } elsif ($pagedatabase_filename_check eq 2){
3195
3196                 # The database filename is invalid, so return an error.
3197
3198                 kiriwrite_error("databasefilenameinvalid");
3199
3200         }
3201
3202         # Check if the confirm value is blank and if it is then
3203         # set the confirm value to 0.
3204
3205         if (!$confirm){
3206
3207                 $confirm = 0;
3208
3209         }
3210
3211         if ($confirm eq 1){
3212
3213                 # The action to edit the template has been confirmed so
3214                 # edit the selected pages.
3215
3216                 # Check the values recieved at UTF8 compliant before
3217                 # converting.
3218
3219                 kiriwrite_variablecheck($newsection, "utf8", 0, 0);
3220                 kiriwrite_variablecheck($newtemplate, "utf8", 0, 0);
3221                 kiriwrite_variablecheck($newsettings, "utf8", 0, 0);
3222
3223                 # Convert the values into proper UTF8 values.
3224
3225                 $newsection     = kiriwrite_utf8convert($newsection);
3226                 $newtemplate    = kiriwrite_utf8convert($newtemplate);
3227                 $newsettings    = kiriwrite_utf8convert($newsettings);
3228
3229                 # Check the length of the variables.
3230
3231                 kiriwrite_variablecheck($altersection, "maxlength", 3, 0);
3232                 kiriwrite_variablecheck($altertemplate, "maxlength", 3, 0);
3233                 kiriwrite_variablecheck($altersettings, "maxlength", 3, 0);
3234                 my $newsection_maxlength_check  = kiriwrite_variablecheck($newsection, "maxlength", 256, 1);
3235                 my $newtemplate_maxlength_check = kiriwrite_variablecheck($newtemplate, "maxlength", 256, 1);
3236                 my $newtemplate_filename_check  = kiriwrite_variablecheck($newtemplate, "filename", 0, 1);
3237                 my $newsettings_maxlength_check = kiriwrite_variablecheck($newsettings, "maxlength", 1, 1);
3238                 my $newsettings_settings_check  = kiriwrite_variablecheck($newsettings, "pagesetting", 0, 1);
3239
3240                 # Check the values and return an error if needed.
3241
3242                 if ($newsection_maxlength_check eq 1 && $altersection eq "on"){
3243
3244                         # The new section name is too long, so return an
3245                         # error.
3246
3247                         kiriwrite_error("pagesectiontoolong");
3248
3249                 }
3250
3251                 if ($newtemplate_maxlength_check eq 1 && $altertemplate eq "on"){
3252
3253                         # The new template name is too long, so return an
3254                         # error.
3255
3256                         kiriwrite_error("templatefilenametoolong");
3257
3258                 }
3259
3260                 # Check if the template filename is set to !skip or !none
3261                 # and skip this check if it is.
3262
3263                 if ($newtemplate eq "!skip" || $newtemplate eq "!none"){
3264
3265                         # Skip this check as the template filename is
3266                         # !skip or !none.
3267
3268                 } else {
3269                         if ($newtemplate_filename_check eq 1 && $altertemplate eq "on" || $newtemplate_filename_check eq 2 && $altertemplate eq "on"){
3270
3271                                 # The new template filename is invalid, so return
3272                                 # an error.
3273
3274                                 kiriwrite_error("templatefilenameinvalid");
3275
3276                         }
3277                 }
3278
3279                 if ($newsettings_maxlength_check eq 1 && $altertemplate eq "on"){
3280
3281                         # The new settings value is too long, so return
3282                         # an error.
3283
3284                         kiriwrite_error("pagesettingstoolong");
3285
3286                 }
3287
3288                 if ($newsettings_settings_check eq 1 && $altertemplate eq "on"){
3289
3290                         # The new settings value is invalid, so return
3291                         # an error.
3292
3293                         kiriwrite_error("pagesettingsinvalid");
3294
3295                 }
3296
3297                 # Load the SQLite Database and get info about the database.
3298
3299                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
3300                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
3301                 $string_handle->execute();
3302
3303                 # Get the database name.
3304
3305                 my @database_info       = $string_handle->fetchrow_array();
3306                 my $database_name       = $database_info[0];
3307                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
3308                 my $database_out        = kiriwrite_convert($database, "normal_display");
3309
3310                 # Define some values for later.
3311
3312                 my @database_page;
3313                 my $edited_list = "";
3314                 my $filename;
3315                 my $filename_sql;
3316                 my $filename_out;
3317                 my $sqlquery_options = "";
3318                 my @sqlquery_list;
3319                 my $sqlquery_option;
3320                 my $page_name;
3321                 my $page_name_out;
3322                 my $newsection_sql;
3323                 my $newtemplate_sql;
3324                 my $newsettings_sql;
3325                 my $pagefound = 0;
3326                 my $pageedited = 0;
3327                 my $sqlquery_seek = 0;
3328                 my $warninglist;
3329
3330                 # Get the date and time information.
3331
3332                 my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
3333
3334                 my $pagelastmodified = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
3335
3336
3337                 # Check if the template filename is !skip and
3338                 # set the alter template value to off if it
3339                 # is.
3340
3341                 if ($newtemplate eq "!skip"){
3342
3343                         $altertemplate = "off";
3344
3345                 }
3346
3347                 # Check if all values are not selected and return
3348                 # an error if they are.
3349
3350                 if ($altersection ne "on" && $altertemplate ne "on" && $altersettings ne "on"){
3351
3352                         # All values are not selected so return
3353                         # an error.
3354
3355                         kiriwrite_error("noeditvaluesselected");
3356
3357                 }
3358
3359                 # Check if each value is meant to be changed on
3360                 # the selected files. Start with the section
3361                 # name.
3362
3363                 if ($altersection eq "on"){
3364
3365                         # Convert the value so that it will work
3366                         # when SQL query is made.
3367
3368                         $newsection_sql = kiriwrite_convert($newsection, "kiriwrite");
3369
3370                         # The section name should be altered so
3371                         # prepare the a part of the SQL query.
3372                         # Check if this is the first part of
3373                         # the SQL query.
3374
3375                         if ($sqlquery_seek eq 0){
3376
3377                                 # This is the first part of the SQL query.
3378
3379                                 $sqlquery_list[$sqlquery_seek] = "pagesection = \'" . $newsection_sql . "\'";
3380                                 $sqlquery_seek++;
3381
3382                         } else {
3383
3384                                 # This isn't the first part of the SQL query.
3385
3386                                 $sqlquery_list[$sqlquery_seek] = ", pagesection = \'" . $newsection_sql . "\'";
3387                                 $sqlquery_seek++;
3388
3389                         }
3390
3391                 }
3392
3393                 # Check if the template name should be changed.
3394
3395                 if ($altertemplate eq "on"){
3396
3397                         # Convert the value so that it will work
3398                         # when SQL query is made.
3399
3400                         $newtemplate_sql        = kiriwrite_convert($newtemplate, "kiriwrite");
3401
3402                         # The section name should be altered so
3403                         # prepare the a part of the SQL query.
3404                         # Check if this is the first part of
3405                         # the SQL query.
3406
3407                         if ($sqlquery_seek eq 0){
3408
3409                                 # This is the first part of the SQL query.
3410
3411                                 $sqlquery_list[$sqlquery_seek] = "pagetemplate = \'" . $newtemplate_sql . "\'";
3412                                 $sqlquery_seek++;
3413
3414                         } else {
3415
3416                                 # This isn't the first part of the SQL query.
3417
3418                                 $sqlquery_list[$sqlquery_seek] = ", pagetemplate = \'" . $newtemplate_sql . "\'";
3419                                 $sqlquery_seek++;
3420
3421                         }
3422
3423                 }
3424
3425                 # Check if the page settings should be changed.
3426
3427                 if ($altersettings eq "on"){
3428
3429                         # Convert the value so that it will work
3430                         # when SQL query is made.
3431
3432                         $newsettings_sql        = kiriwrite_convert($newsettings, "kiriwrite");
3433
3434                         # The section name should be altered so
3435                         # prepare the a part of the SQL query.
3436                         # Check if this is the first part of
3437                         # the SQL query.
3438
3439                         if ($sqlquery_seek eq 0){
3440
3441                                 # This is the first part of the SQL query.
3442
3443                                 $sqlquery_list[$sqlquery_seek] = "pagesettings = \'" . $newsettings_sql . "\'";
3444                                 $sqlquery_seek++;
3445
3446                         } else {
3447
3448                                 # This isn't the first part of the SQL query.
3449
3450                                 $sqlquery_list[$sqlquery_seek] = ", pagesettings = \'" . $newsettings_sql . "\'";
3451                                 $sqlquery_seek++;
3452
3453                         }
3454
3455                 }
3456
3457                 # Add a new modification date.
3458
3459                 $sqlquery_list[$sqlquery_seek] = ", lastmodified = \'" . $pagelastmodified . "\'";
3460
3461                 # Create the line for the needed SQL query.
3462
3463                 foreach $sqlquery_option (@sqlquery_list){
3464
3465                         # Add the line to the needed SQL query.
3466
3467                         $sqlquery_options = $sqlquery_options . $sqlquery_option;
3468
3469                 }
3470
3471                 # Edit each filename.
3472
3473                 foreach $filename (@filelist){
3474
3475                         # Check if the page filename exists in the
3476                         # database.
3477
3478                         $filename_sql   = kiriwrite_convert($filename, "kiriwrite");
3479                         $filename_out   = kiriwrite_convert($filename, "normal_display");
3480                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filename_sql . '\'') or kiriwrite_error("databasefileinvalid");
3481                         $string_handle->execute();
3482
3483                         # Check if the filename given exists and if it
3484                         # doesn't then skip this filename and go onto
3485                         # the next filename.
3486
3487                         while (@database_page = $string_handle->fetchrow_array()){
3488
3489                                 $pagefound = 1;
3490
3491                         }
3492
3493                         if ($pagefound eq 0){
3494
3495                                 # The page was not find in the database so
3496                                 # add a warning saying it could not be
3497                                 # found in the database and process the
3498                                 # next file.
3499
3500
3501                                 $warninglist = $warninglist . "The page \'" . $filename_out . "\'could not be found." . "<br>";
3502                                 next;
3503
3504                         }
3505
3506                         # Get the page name.
3507
3508                         $string_handle->execute();
3509                         @database_page  = $string_handle->fetchrow_array();
3510                         $page_name      = $database_page[1];
3511                         $page_name_out  = kiriwrite_convert($page_name, "normal_display");
3512
3513                         # Alter the values of the page using the values recieved.
3514
3515                         $string_handle  = $database_handle->prepare('UPDATE kiriwrite_database_pages SET ' . $sqlquery_options . ' WHERE filename = \'' . $filename_sql . '\'');
3516                         $string_handle->execute();
3517
3518                         # Add the page to the list of edited pages. Check if
3519                         # the page name is blank.
3520
3521                         if (!$page_name_out){
3522
3523                                 # The page name is blank so write no name.
3524
3525                                 $edited_list    = $edited_list . "The page (" . $filename_out . ") was edited." . "<br>";
3526
3527                         } else {
3528
3529                                 # Add the page to the list of edited pages.
3530
3531                                 $edited_list    = $edited_list . "The page called '" . $page_name_out . "' (" . $filename_out . ") was edited." . "<br>";
3532
3533                         }
3534
3535                         # Increment the counter of edited pages.
3536
3537                         $pageedited++;
3538
3539                 }
3540
3541                 $pagedata       = $pagedata . "<h2>Edit selected pages</h2>";
3542
3543                 # Check if the counter of edited pages is 0 and if it is
3544                 # then write a message saying that no pages were edited
3545                 # else write a message listing all of the pages edited.
3546
3547                 if ($pageedited eq 0){
3548
3549                         $pagedata       = $pagedata . "No pages were edited in the '" . $database_name_out . "' database. <br><br>";
3550
3551                 } else {
3552
3553                         # Write out the message saying that the selected pages
3554                         # were edited.
3555
3556                         $pagedata       = $pagedata . "The selected pages in the '" . $database_name_out . "' database have been edited:<br><br>";
3557                         $pagedata       = $pagedata . "<div class=\"datalist\">";
3558                         $pagedata       = $pagedata . $edited_list;
3559                         $pagedata       = $pagedata . "</div><br>";
3560
3561                 }
3562
3563                 # Check if any warnings have occured and write a message
3564                 # if any warnings did occur.
3565
3566                 if ($warninglist){
3567
3568                         # One or several warnings have occured so
3569                         # write a message.
3570
3571                         $pagedata       = $pagedata . "The following errors/warnings occured while editing the selected pages:<br><br>";
3572                         $pagedata       = $pagedata . "<div class=\"datalist\">";
3573                         $pagedata       = $pagedata . $warninglist;
3574                         $pagedata       = $pagedata . "</div><br>";
3575
3576                 }
3577
3578                 # Write a link going back to the page list for
3579                 # the selected database.
3580
3581                 $pagedata       = $pagedata . "<a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
3582
3583                 return $pagedata;
3584
3585         } elsif ($confirm eq 0){
3586
3587                 # The action to edit the template has not been confirmed
3588                 # so write a form out instead.
3589
3590                 # Load the SQLite Database and get info about the database.
3591
3592                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
3593                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or kiriwrite_error("databasefileinvalid");
3594                 $string_handle->execute();
3595
3596                 # Get the database name.
3597
3598                 my @database_info       = $string_handle->fetchrow_array();
3599                 my $database_name       = $database_info[0];
3600                 my $database_name_out   = kiriwrite_convert($database_name, "normal_display");
3601                 my $database_out        = kiriwrite_convert($database, "normal_display");
3602
3603                 # Define some variables for later.
3604
3605                 my @database_page;
3606                 my @database_templates;
3607                 my @filenames;
3608                 my @page_info;
3609                 my @pagenames;
3610                 my $filelist_filename;
3611                 my $filelist_filename_sql;
3612                 my $filelist_filename_out;
3613                 my $filename;
3614                 my $pagefound;
3615                 my $pagelist = "";
3616                 my $pagelistformdata = "";
3617                 my $pageseek = 0;
3618                 my $page_name;
3619                 my $page_filename;
3620                 my $template_data;
3621                 my $template_filename;
3622                 my $template_name;
3623                 my $template_warning;
3624
3625                 # Get the information about each page that is going
3626                 # to be edited.
3627
3628                 foreach $filelist_filename (@filelist){
3629
3630                         $filelist_filename_sql  = kiriwrite_convert($filelist_filename, "kiriwrite");
3631                         $filelist_filename_out  = kiriwrite_convert($filelist_filename, "normal_display");
3632
3633                         $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages WHERE filename = \'' . $filelist_filename . '\' LIMIT 1') or kiriwrite_error("databasefileinvalid");
3634
3635                         $string_handle->execute();
3636
3637                         # Check if the filename given exists and if it
3638                         # doesn't then skip this filename and go onto
3639                         # the next filename.
3640
3641                         while (@page_info = $string_handle->fetchrow_array()){
3642
3643                                 $pagefound = 1;
3644
3645                         }
3646
3647                         if ($pagefound eq 0){
3648
3649                                 next;
3650
3651                         }
3652
3653                         # Get the data again.
3654
3655                         $string_handle->execute();
3656                         @page_info      = $string_handle->fetchrow_array();
3657
3658                         # Add the page name and file name to their seperate
3659                         # arrays.
3660
3661                         $pagenames[$pageseek]   = $page_info[1];
3662                         $filenames[$pageseek]   = $page_info[0];
3663
3664                         # Add the form data for the page filename.
3665
3666                         # BLEARGH
3667
3668                         $pagelistformdata       = $pagelistformdata . "<input type=\"hidden\" name=\"name[" . ($pageseek + 1) . "]\" value=\"on\">";
3669                         $pagelistformdata       = $pagelistformdata . "<input type=\"hidden\" name=\"id[" . ($pageseek + 1) . "]\" value=\"" . $filelist_filename_out . "\">";
3670
3671                         # Increment the page seek counter and reset the
3672                         # page found value.
3673
3674                         $pageseek++;
3675                         $pagefound = 0;
3676
3677                 }
3678
3679                 # Check if any pages were found in the database and return
3680                 # an error if not.
3681
3682                 if ($pageseek eq 0){
3683
3684                         # No pages were found so return an error.
3685
3686                         kiriwrite_error("nopagesselected");
3687
3688                 }
3689
3690                 # Get the template list and select the template that is being used by
3691                 # the page, check the permissions and if the template database exists.
3692
3693                 my $template_file_exists        = kiriwrite_fileexists("templates.db");
3694                 my $template_file_permissions   = kiriwrite_filepermissions("templates.db", 1, 0, 0);
3695
3696                 if ($template_file_exists eq 1){
3697
3698                         # The template database does not exist, so write a warning messsage.
3699
3700                         $template_warning = "The template database does not exist. Existing template settings for selected pages kept.";
3701
3702                 }
3703
3704                 if ($template_file_permissions eq 1 && $template_file_exists ne 1){
3705
3706                         # The template database has invalid permissions set, so write a warning message.
3707
3708                         $template_warning = "The template database has invalid permissions set. Existing template settings for selected pages kept.";
3709
3710                 }
3711
3712                 # Get the list of templates.
3713
3714                 if (!$template_warning){
3715
3716                         # Load the templates database and get the templates.
3717
3718                         $database_handle        = DBI->connect("dbi:SQLite:templates.db");
3719                         $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $template_warning = "The template database is in an invalid format. Existing template settings for selected pages kept.";
3720
3721                         if (!$template_warning){
3722
3723                                 $string_handle->execute();
3724
3725                                 $template_data = "<select name=\"newtemplate\">";
3726
3727                                 while (@database_templates = $string_handle->fetchrow_array()){
3728
3729                                         # Get the filename and name of the database.
3730
3731                                         $template_filename      = $database_templates[0];
3732                                         $template_name          = $database_templates[1];
3733
3734                                         # Convert the values so that they can be displayed in the list.
3735
3736                                         $template_filename      = kiriwrite_convert($template_filename, "normal_display");
3737                                         $template_name          = kiriwrite_convert($template_name, "normal_display");
3738
3739                                         # Add the template to the list of templates.
3740
3741                                         $template_data = $template_data .  "<option value=\"" . $template_filename . "\">" . $template_name . " (" . $template_filename .")</option>";
3742
3743                                 }
3744
3745                         # Add the option to not use a template at all.
3746
3747                         $template_data = $template_data . "<option value=\"!none\" selected>Don't use a template</option>";
3748                         $template_data = $template_data . "</select>";
3749
3750                         }
3751
3752                 }
3753
3754                 # Process the list of selected pages.
3755
3756                 $pageseek = 1;
3757                 foreach $filename (@filenames){
3758
3759                         # Process each filename.
3760
3761                         $page_name      = $pagenames[$pageseek - 1];
3762                         $page_filename  = $filenames[$pageseek - 1];
3763
3764                         # Check if the page name is blank.
3765
3766                         if (!$page_name){
3767
3768                                 # Write a message saying there's no page name.
3769
3770                                 $pagelist       = $pagelist . "<i>No Name</i>" . " (" . $page_filename . ")" . "<br>"
3771
3772                         } else {
3773
3774                                 # Append the page to the list of pages to edit.
3775
3776                                 $pagelist       = $pagelist . $page_name . " (" . $page_filename . ")" . "<br>";
3777
3778                         }
3779
3780                         $pageseek++;
3781
3782                 }
3783
3784                 # Write a form for editing the selected pages.
3785
3786                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
3787                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">";
3788                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"multiedit\">";
3789                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_out . "\">";
3790                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . ($pageseek - 1) . "\">";
3791                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
3792                 $pagedata = $pagedata . "<h2>Edit selected pages</h2>";
3793                 $pagedata = $pagedata . "The following pages from the '" . $database_name_out . "' database will be altered:<br><br>";
3794                 $pagedata = $pagedata . "<div class=\"datalist\">";
3795                 $pagedata = $pagedata . $pagelist;
3796                 $pagedata = $pagedata . "</div><br>";
3797                 $pagedata = $pagedata . $pagelistformdata;
3798                 $pagedata = $pagedata . "Using the values below (click on the checkbox for each value to be edited on the selected pages):<br><br>";
3799                 $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
3800                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Alter</td><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
3801                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"checkbox\" name=\"altersection\"></td><td class=\"tablecell1\">Page Section</td><td class=\"tablecell1\"><input type=\"text\" name=\"newsection\" size=\"64\" maxlength=\"256\"></td></tr>";
3802
3803                 # Check if a warning for template database has been written
3804                 # and return the warning message if it has else write the
3805                 # list of templates.
3806
3807                 if ($template_warning){
3808
3809                         # There is a message in the template warning variable
3810
3811                         $pagedata = $pagedata . "<tr><td class=\"tablecell2\"><input type=\"checkbox\" name=\"altertemplate\"></td><td class=\"tablecell2\">Page Template</td><td class=\"tablecell2\"><input type=\"hidden\" name=\"newtemplate\" value=\"!skip\">" . $template_warning . "</td></tr>";
3812
3813                 } else {
3814
3815                         $pagedata = $pagedata . "<tr><td class=\"tablecell2\"><input type=\"checkbox\" name=\"altertemplate\"></td><td class=\"tablecell2\">Page Template</td><td class=\"tablecell2\">" . $template_data . "</td></tr>";
3816
3817                 }
3818
3819                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\"><input type=\"checkbox\" name=\"altersettings\"></td><td class=\"tablecell1\">Page Settings</td><td class=\"tablecell1\"><input type=\"radio\" name=\"newsettings\" value=\"1\"> Use page name and section name.<br><input type=\"radio\" name=\"newsettings\" value=\"2\"> Use the page name only.<br><input type=\"radio\" name=\"newsettings\" value=\"3\"> Use the section name only.<br><input type=\"radio\" name=\"newsettings\" value=\"0\" checked> Don't use page name or section name.<br></td></tr>";
3820                 $pagedata = $pagedata . "</table><br>";
3821                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit selected pages\"> | <a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_out . "\">Return to the page list for the '" . $database_name_out . "' database.</a>";
3822                 $pagedata = $pagedata . "</form>";
3823
3824                 return $pagedata;
3825
3826         } else {
3827
3828                 # The confirm value is something else other than
3829                 # 1 or 0, so return an error.
3830
3831                 kiriwrite_error("invalidvariable");
3832
3833         }
3834
3835 }
3836
3837 sub kiriwrite_page_list{
3838 #################################################################################
3839 # kiriwrite_page_list: Lists pages from an database.                            #
3840 #                                                                               #
3841 # Usage:                                                                        #
3842 #                                                                               #
3843 # kiriwrite_page_list([database]);                                              #
3844 #                                                                               #
3845 # database      Specifies the database to retrieve the pages from.              #
3846 #################################################################################
3847
3848         # Get the database file name from what was passed to the subroutine.
3849
3850         my ($database_file) = @_;
3851
3852         # Load the required Perl modules.
3853
3854         my $xsl = XML::Simple->new();
3855         use DBI;
3856
3857         # Check if the database_file variable is empty, if it is then print out a
3858         # select box asking the user to select a database from the list.
3859
3860         if (!$database_file) {
3861
3862                 # Define the variables required for this section.
3863
3864                 my $pagedata            = "";
3865                 my $dblistdata          = "";
3866                 my $data_file           = "";
3867                 my $data_file_length    = 0;
3868                 my $data_file_friendly  = "";
3869                 my $database_handle     = "";
3870                 my $string_handle       = "";
3871                 my $database_name       = "";
3872                 my $file_permissions    = "";
3873                 my @database_info;
3874                 my @data_directory;
3875
3876                 # Open the data directory and get all of the databases.
3877
3878                 opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
3879                 @data_directory = grep /m*\.db/, readdir(DATADIR);
3880                 closedir(DATADIR);
3881
3882                 # Get the information about each database (the short name and friendly name).
3883
3884                 foreach $data_file (@data_directory){
3885
3886                         # Give the filename a friendly name.
3887
3888                         $data_file_length       = length($data_file);
3889                         $data_file_friendly     = substr($data_file, 0, $data_file_length - 3);
3890
3891                         # Check if the permissions for the database are valid.
3892
3893                         $file_permissions       = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' .$data_file, 1, 0);
3894
3895                         if ($file_permissions ne 0){
3896
3897                                 # The permissions for the database are invalid
3898                                 # so process the next database.
3899
3900                                 next;
3901
3902                         }
3903
3904                         # Load the SQLite database.
3905
3906                         $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $data_file);
3907                         $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or next;
3908                         $string_handle->execute();
3909                         @database_info          = $string_handle->fetchrow_array();
3910
3911                         # Get the database name from the results.
3912
3913                         $database_name          = $database_info[0];
3914                         $database_name          = kiriwrite_convert($database_name, "normal_display");
3915
3916                         # Append the database to the list of databases available.
3917
3918                         $dblistdata = $dblistdata . "<option value=\"" . $data_file_friendly . "\">" . $database_name . "</option>";
3919
3920                 }
3921
3922                 # Write the page data.
3923
3924                 $pagedata = "<h2>View Pages</h2>\r\n";
3925                 $pagedata = $pagedata . "No database selected. Please select a database from the drop-down list below and then press the \'View\' button to view the pages in the selected database.<br><br>";
3926
3927                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
3928                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">\r\n";
3929                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"view\">\r\n";
3930                 $pagedata = $pagedata . "<select name=\"database\">";
3931                 $pagedata = $pagedata . $dblistdata;
3932                 $pagedata = $pagedata . "</select>&nbsp;|&nbsp;";
3933                 $pagedata = $pagedata . "<input type=\"submit\" value=\"View\">";
3934                 $pagedata = $pagedata . "</form>&nbsp;<br>";
3935
3936                 return $pagedata;
3937
3938         } else {
3939
3940                 my @database_pages;
3941                 my @database_info;
3942                 my $tabledata           = "";
3943                 my $pagedata            = "";
3944                 my $pagemultioptions    = "";
3945                 my $database_handle     = "";
3946                 my $string_handle       = "";
3947                 my $db_friendlyname     = "";
3948                 my $tablestyle          = "";
3949
3950                 my $page_filename       = "";
3951                 my $page_name           = "";
3952                 my $page_description    = "";
3953                 my $page_modified       = "";
3954
3955                 my $tablestyletype      = 0;
3956                 my $page_count          = 0;
3957                 my $db_file_notblank    = 0;
3958
3959                 # The database_file variable is not blank, so print out a list of pages from
3960                 # the selected database.
3961
3962                 # Preform a variable check on the database filename to make sure that it is
3963                 # valid before using it.
3964
3965                 kiriwrite_variablecheck($database_file, "filename", "", 0);
3966                 kiriwrite_variablecheck($database_file, "maxlength", 64, 0);
3967
3968                 # Check if the specified database file exists,
3969                 # if it does exist then continue otherwise return an error saying the database
3970                 # could not be found.
3971
3972                 if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db'){
3973
3974                         # Check that the permissions for the database file are valid.
3975
3976                         my $database_db_permissions     = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db', 1, 0, 0);
3977
3978                         if ($database_db_permissions eq 1){
3979
3980                                 kiriwrite_error("databaseinvalidpermissions");
3981
3982                         }
3983
3984                         # Load the SQLite database.
3985
3986                         $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_file . '.db');
3987
3988                         # Get the database name.
3989
3990                         $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or kiriwrite_error("databasenameinvalid");
3991                         $string_handle->execute();
3992
3993                         @database_info = $string_handle->fetchrow_array();
3994
3995                         $db_friendlyname = $database_info[0];
3996
3997                         $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_database_pages") or kiriwrite_error("databasenameinvalid");
3998                         $string_handle->execute();
3999
4000                         # Write the table header into the tabledata string.
4001
4002                         $tabledata = "<table cellpadding=\"5\" cellspacing=\"0\">\r\n<tr>\r\n\t<td class=\"tablecellheader\"></td>\r\n\t<td class=\"tablecellheader\">Page Location</td>\r\n\t<td class=\"tablecellheader\">Page Name</td>\r\n\t<td class=\"tablecellheader\">Page Description</td>\r\n\t<td class=\"tablecellheader\">Last Modified</td>\r\n\t<td class=\"tablecellheader\">Options</td>\r\n</tr>";
4003
4004                         # Write the results out as a list and append it to the
4005                         # tabledata string.
4006
4007                         while (@database_pages = $string_handle->fetchrow()){
4008
4009                                 $page_filename          = kiriwrite_convert($database_pages[0], "normal_display");
4010                                 $page_name              = kiriwrite_convert($database_pages[1], "normal_display");
4011                                 $page_description       = kiriwrite_convert($database_pages[2], "normal_display");
4012                                 $page_modified          = kiriwrite_convert($database_pages[7], "date");
4013                                 $page_modified          = kiriwrite_convert($page_modified, "normal_display");
4014
4015                                 if ($database_pages[0]){
4016                                         $page_count++;
4017                                 } else {
4018                                         next;
4019                                 }
4020
4021                                 if ($tablestyletype eq 0){
4022
4023                                         $tablestyle = "tablecell1";
4024                                         $tablestyletype = 1;
4025
4026                                 } else {
4027
4028                                         $tablestyle = "tablecell2";
4029                                         $tablestyletype = 0;
4030
4031                                 }
4032
4033                                 # Check if the page name and description names
4034                                 # are blank and if they are write a message saying that
4035                                 # field contains no data.
4036
4037                                 if ($page_name eq ""){
4038
4039                                         $page_name = "<i>No Name</i>";
4040
4041                                 }
4042
4043                                 if ($page_description eq ""){
4044
4045                                         $page_description = "<i>No Description</i>";
4046
4047                                 }
4048
4049                                 if ($page_modified eq ""){
4050
4051                                         $page_modified = "<i>No Date</i>";
4052
4053                                 }
4054
4055                                 $tabledata = $tabledata . "<tr><td class=\"" . $tablestyle . "\"><input type=\"hidden\" name=\"id[" . $page_count . "]\" value=\"" . $database_pages[0] . "\"><input type=\"checkbox\" name=\"name[" . $page_count . "]\"></td><td class=\"" . $tablestyle . "\">" . $page_filename ."</td><td class=\"" . $tablestyle . "\">" . $page_name . "</td><td class=\"" . $tablestyle . "\">" . $page_description . "</td><td class=\"" . $tablestyle . "\">" . $page_modified . "</td><td class=\"" . $tablestyle . "\"><a href=\"kiriwrite.cgi?mode=page&action=edit&database=" . $database_file . "&page=" . $page_filename ."\">Edit</a> <a href=\"kiriwrite.cgi?mode=page&action=delete&database=" . $database_file . "&page=" . $page_filename . "\">Delete</td></tr>";
4056
4057
4058
4059                         }
4060
4061                         # Check if the page count is more than
4062
4063                         if ($page_count > 0){
4064                                 $db_file_notblank = 1;
4065                         }
4066
4067                         # Append the closing table part into the tabledata string.
4068
4069                         $tabledata = $tabledata . "</table>";
4070
4071                 } else {
4072                         # Either the database file, the database configuration file or both are missing
4073                         # so return an error saying that certain files are missing.
4074
4075                         kiriwrite_error("databasemissingfile");
4076                 }
4077
4078                 # Check if the database really was not blank and if it was, write a message saying that
4079                 # no pages existed in the database else write the list of pages in the database.
4080
4081                 $db_friendlyname = kiriwrite_convert($db_friendlyname, "normal_display");
4082
4083                 if ($db_file_notblank eq 0){
4084
4085                         $pagedata = "<h2>Page list for '" . $db_friendlyname . "'</h2>";
4086                         $pagedata = $pagedata . "<div class=\"errorbox\">No pages exist in this database. To create a page for this database, click on Add Page link at the top of the page.</div>";
4087
4088                 } else {
4089
4090                         $pagemultioptions = "<input type=\"reset\" value=\"Select None\"> | <button name=\"action\" value=\"multidelete\">Delete Selected</button> | <button name=\"action\" value=\"multimove\">Move Selected</button> | <button name=\"action\" name=\"action\" value=\"multicopy\">Copy Selected</button> | <button name=\"action\" value=\"multiedit\">Edit Selected</button>";
4091
4092                         $pagedata = "<h2>Page list for '" . $db_friendlyname . "'</h2>";
4093                         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
4094                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"page\">\r\n";
4095                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $page_count . "\">\r\n";
4096                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">\r\n";
4097                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_file . "\">\r\n";
4098                         $pagedata = $pagedata . $pagemultioptions . "<p>\r\n";
4099                         $pagedata = $pagedata . $tabledata;
4100                         $pagedata = $pagedata . "<br>" . $pagemultioptions . "<p>\r\n";
4101                         $pagedata = $pagedata . "</form>";
4102
4103                 }
4104
4105                 return $pagedata;
4106
4107         }
4108
4109 }
4110
4111 sub kiriwrite_page_multipleselect{
4112 #################################################################################
4113 # kiriwrite_page_multipleselect: Gets the multiple page selections from a       #
4114 # database and processes them into a single which can be used in the            #
4115 # kiriwrite_page_delete.                                                        #
4116 #                                                                               #
4117 # Usage:                                                                        #
4118 #                                                                               #
4119 # kiriwrite_page_multipleselect();                                              #
4120 #################################################################################
4121
4122         # Load the required perl modules for this subroutine.
4123
4124         my $query = new CGI;
4125
4126         # Setup some variables that will be used later on.
4127
4128         my $page_select_seek = 1;
4129         my $page_current_value = "";
4130         my $selectionlist = "";
4131
4132         # Get the required variables from the HTTP query.
4133
4134         my $page_count = $query->param('count');
4135
4136         do {
4137
4138                 # Get the current value of the selected page's checkbox.
4139
4140                 $page_current_value = $query->param('name[' . $page_select_seek . ']');
4141
4142                 # If page_current_value is undefinied or blank, set page_current_value
4143                 # to off.
4144
4145                 if (!$page_current_value){
4146
4147                         $page_current_value = "off";
4148
4149                 }
4150
4151                 # Check if the page_current_value is set to 'on' if it is append the
4152                 # current page seek value to the selection list.
4153
4154                 if ($page_current_value eq "on"){
4155
4156                         # Append the current seek value to the selection list.
4157
4158                         $selectionlist = $selectionlist . $page_select_seek . "|";
4159
4160                 }
4161
4162                 # Increment the page selection seeking counter.
4163
4164                 $page_select_seek++;
4165
4166         } until ($page_select_seek eq $page_count);
4167
4168         return $selectionlist;
4169
4170 }
4171
4172 sub kiriwrite_template_add{
4173 #################################################################################
4174 # kiriwrite_template_add: Add a template to the template folder                 #
4175 #                                                                               #
4176 # Usage:                                                                        #
4177 #                                                                               #
4178 # kiriwrite_template_add(filename, name, description, layout, confirm);         #
4179 #                                                                               #
4180 # filename      The filename of the new template.                               #
4181 # name          The name of the template.                                       #
4182 # description   The description of the template.                                #
4183 # layout        The layout of the new template.                                 #
4184 # confirm       Confirm the action of creating a new template.                  #
4185 #################################################################################
4186
4187         # Get the variables that were passed to the subroutine.
4188
4189         my ($templatefilename, $templatename, $templatedescription, $templatelayout, $confirm) = @_;
4190
4191         # Load the needed Perl Modules
4192
4193         use DBI;
4194
4195         # Check if the confirm value is blank and if it is then set confirm to 0.
4196
4197         if (!$confirm){
4198
4199                 # The confirm value is blank, so set the value of confirm to 0.
4200
4201                 $confirm = 0;
4202
4203         }
4204
4205         if ($confirm eq 1){
4206
4207                 # Check (validate) each of the values.
4208
4209                 kiriwrite_variablecheck($templatename, "utf8", 0, 0);
4210                 kiriwrite_variablecheck($templatedescription, "utf8", 0, 0);
4211                 kiriwrite_variablecheck($templatelayout, "utf8", 0, 0);
4212
4213                 # Convert the values into proper UTF8 strings that can be used.
4214
4215                 $templatename           = kiriwrite_utf8convert($templatename);
4216                 $templatedescription    = kiriwrite_utf8convert($templatedescription);
4217                 $templatelayout         = kiriwrite_utf8convert($templatelayout);
4218
4219                 # Check the length of the converted UTF8 strings.
4220
4221                 my $templatefilename_length_check       = kiriwrite_variablecheck($templatefilename, "maxlength", 64, 1);
4222                 my $templatename_length_check           = kiriwrite_variablecheck($templatename, "maxlength", 512, 1);
4223                 my $templatedescription_length_check    = kiriwrite_variablecheck($templatedescription, "maxlength", 512, 1);
4224                 kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
4225
4226                 if ($templatefilename_length_check eq 1){
4227
4228                         # The template filename length is too long, so return an error.
4229
4230                         kiriwrite_error("templatefilenametoolong");
4231
4232                 }
4233
4234                 if ($templatename_length_check eq 1){
4235
4236                         # The template name length is too long, so return an error.
4237
4238                         kiriwrite_error("templatenametoolong");
4239
4240                 }
4241
4242
4243                 if ($templatedescription_length_check eq 1){
4244
4245                         # The template description length is too long, so return an error.
4246
4247                         kiriwrite_error("templatedescriptiontoolong");
4248
4249                 }
4250
4251                 # Check if the filename specified is a valid filename.
4252
4253                 kiriwrite_variablecheck($templatefilename, "filename", "", 0);
4254
4255                 # Check if the template database file permissions are valid and
4256                 # return an error if they aren't.
4257
4258                 my $template_database_permissions = kiriwrite_filepermissions("templates.db", 1, 1, 1);
4259
4260                 if ($template_database_permissions eq 1){
4261
4262                         # Template database has invalid permissions set, so return
4263                         # an error.
4264
4265                         kiriwrite_error("templatedatabasefileinvalidpermissions");
4266                 }
4267
4268                 # Check if the template database exists and if it doesn't then
4269                 # create the database and populate it.
4270
4271                 my $template_database_exists = kiriwrite_fileexists("templates.db");
4272                 my $database_handle;
4273                 my $string_handle;
4274
4275                 if ($template_database_exists eq 1){
4276
4277                         # The template database does not exist, so try to create a database.
4278
4279                         # Check if the directory has valid permissions to create files (and
4280                         # thus be able create a template database).
4281
4282                         my $directory_permissions = kiriwrite_filepermissions(".", 1, 1, 0);
4283
4284                         if ($directory_permissions eq 1){
4285
4286                                 # The template database cannot be created because of invalid directory
4287                                 # permissions so return an error.
4288
4289                                 kiriwrite_error("templatedatabasefilenotcreated");
4290                         }
4291
4292                         # Create the SQLite database for the templates and populate it.
4293
4294                         $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
4295                         $string_handle          = $database_handle->prepare('CREATE TABLE kiriwrite_templates(
4296                                 filename varchar(64) primary key,
4297                                 templatename varchar(512),
4298                                 templatedescription varchar(512),
4299                                 templatelayout text,
4300                                 datemodified datetime
4301                         )') or die(kiriwrite_error("templatedatabaseinvalidformat"));
4302                         $string_handle->execute();
4303
4304                 }
4305
4306                 # Check if the template filename is already used and if it is then
4307                 # return an error.
4308
4309                 $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
4310                 $string_handle          = $database_handle->prepare('select * from kiriwrite_templates where filename = \'' . $templatefilename . '\' limit 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
4311                 $string_handle->execute();
4312
4313                 my @database_template_check     = $string_handle->fetchrow_array();
4314                 my $template_checkname          = $database_template_check[0];
4315
4316                 if ($template_checkname){
4317
4318                         # A template already exists with the filename given, so return an error.
4319
4320                         kiriwrite_error("templatefilenameexists");
4321                 }
4322
4323                 # Get the current date.
4324
4325                 my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
4326
4327                 my $templatedate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
4328
4329                 # Convert the values that are going to be added for storing in the database.
4330
4331                 $templatename           = kiriwrite_convert($templatename, "kiriwrite");
4332                 $templatedescription    = kiriwrite_convert($templatedescription, "kiriwrite");
4333                 $templatelayout         = kiriwrite_convert($templatelayout, "kiriwrite");
4334
4335                 # Add the template to the template database.
4336
4337                 $string_handle          = $database_handle->prepare('INSERT INTO kiriwrite_templates values(
4338                                 \'' . $templatefilename . '\',
4339                                 \'' . $templatename . '\',
4340                                 \'' . $templatedescription . '\',
4341                                 \'' . $templatelayout . '\',
4342                                 \'' . $templatedate . '\'
4343                 )');
4344                 $string_handle->execute();
4345
4346                 # Print out the confirmation message.
4347
4348                 my $pagedata = "<h2>Template Added</h2>";
4349                 $pagedata = $pagedata . "The template called '" . $templatename ."' was sucessfully created.<br><br>";
4350                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=template\">Return to the templates list</a>";
4351                 return $pagedata;
4352
4353         } else {
4354                 # No confirmation was made, so print out a form for adding a template.
4355
4356                 my $pagedata = "<h2>Add Template</h2>";
4357                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"post\">";
4358                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
4359                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
4360                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
4361                 $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
4362                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
4363                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Name:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatename\" maxlength=\"512\" size=\"64\"></td></tr>";
4364                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Description:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatedescription\" maxlength=\"512\" size=\"64\"></td></tr>";
4365                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filename:</td><td class=\"tablecell2\"><input type=\"text\" name=\"templatefilename\" maxlength=\"64\" size=\"32\"></td></tr>";
4366                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Template Layout:</td><td class=\"tablecell2\"><textarea name=\"templatelayout\" rows=\"15\" cols=\"50\" wrap=off></textarea></td></tr>";
4367                 $pagedata = $pagedata . "</table><br>";
4368                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Create New Template\"> | <input type=\"reset\" value=\"Clear Settings\">";
4369                 $pagedata = $pagedata . "</form>";
4370
4371                 return $pagedata;
4372
4373         }
4374
4375
4376 }
4377
4378 sub kiriwrite_template_edit{
4379 #################################################################################
4380 # kiriwrite_template_edit: Edit a template from the template folder.            #
4381 #                                                                               #
4382 # Usage:                                                                        #
4383 #                                                                               #
4384 # kiriwrite_template_edit(filename, [newfilename], [newname], [newdescription], #
4385 #                               [templatelayout], [confirm]);                   #
4386 #                                                                               #
4387 # filename              The current filename of the template to edit.           #
4388 # newfilename           The new filename of the template to edit.               #
4389 # newname               The new name of the template being edited.              #
4390 # newdescription        The new description of the template being edited.       #
4391 # templatelayout        The modified/altered template layout.                   #
4392 # confirm               Confirms the action to edit a template and its          #
4393 #                       settings.                                               #
4394 #################################################################################
4395
4396         # Get all the variables that have been passed to the subroutine.
4397
4398         my ($templatefilename, $templatenewfilename, $templatenewname, $templatenewdescription, $templatelayout, $confirm) = @_;
4399
4400         # Load the Perl modules required for this subroutine.
4401
4402         use DBI;
4403
4404         # Define the pagedata variable for later on.
4405
4406         my $pagedata = "";
4407
4408         # Check if the confirm variable is blank, if it is then
4409         # set confirm to '0'
4410
4411         if (!$confirm){
4412
4413                 # confirm is uninitalised/blank, so set the value of confirm
4414                 # to '0'
4415
4416                 $confirm = 0;
4417
4418         }
4419
4420         # Check if the template filename is blank and if it is, then return
4421         # an error.
4422
4423         if (!$templatefilename){
4424
4425                 kiriwrite_error("templatefilenameblank");
4426
4427         }
4428
4429         if ($confirm eq 1){
4430
4431                 # Check certain strings to see if they UTF8 compiliant.
4432
4433                 kiriwrite_variablecheck($templatenewname, "utf8", 0, 0);
4434                 kiriwrite_variablecheck($templatenewdescription, "utf8", 0, 0);
4435                 kiriwrite_variablecheck($templatelayout, "utf8", 0, 0);
4436
4437                 # Convert the values into proper UTF8 strings.
4438
4439                 $templatenewname        = kiriwrite_utf8convert($templatenewname);
4440                 $templatenewdescription = kiriwrite_utf8convert($templatenewdescription);
4441                 $templatelayout         = kiriwrite_utf8convert($templatelayout);
4442
4443                 # Check if the filenames recieved are valid filenames.
4444
4445                 kiriwrite_variablecheck($templatenewfilename, "maxlength", 64, 0);
4446                 kiriwrite_variablecheck($templatenewdescription, "maxlength", 512, 0);
4447                 kiriwrite_variablecheck($templatenewname, "maxlength", 512, 0);
4448                 kiriwrite_variablecheck($templatefilename, "maxlength", 64, 0);
4449                 kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
4450
4451                 kiriwrite_variablecheck($templatefilename, "filename", "", 0);
4452                 kiriwrite_variablecheck($templatenewfilename, "filename", "", 0);
4453
4454                 # Check that the template database file exists and the permissions
4455                 # of the template database are valid.
4456
4457                 my $template_database_exists            = kiriwrite_fileexists("templates.db");
4458                 my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
4459
4460                 if ($template_database_exists eq 1){
4461
4462                         # the template database does not exist so return an error.
4463
4464                         kiriwrite_error("templatedatabasemissing");
4465
4466                 }
4467
4468                 if ($template_database_permissions eq 1){
4469
4470                         # The template database permissions are set incorrectly so
4471                         # return an error.
4472
4473                         kiriwrite_error("templatedatabaseinvalidpermissions");
4474
4475                 }
4476
4477                 # Get the date.
4478
4479                 my ($created_second, $created_minute, $created_hour, $created_day, $created_month, $created_year, $created_weekday, $created_yearday, $created_dst) = localtime;
4480
4481                 my $templatenewdate = $created_year . '-' . $created_month . '-' . $created_day . ' ' . $created_hour . ':' . $created_minute . ':' . $created_second;
4482
4483                 # Convert the values so that they don't break when entering them into the SQL query.
4484
4485                 $templatenewname        = kiriwrite_convert($templatenewname, "kiriwrite");
4486                 $templatenewdescription = kiriwrite_convert($templatenewdescription, "kiriwrite");
4487                 $templatelayout         = kiriwrite_convert($templatelayout, "kiriwrite");
4488
4489                 # Load the SQLite database.
4490
4491                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
4492                 my $string_handle       = $database_handle->prepare('UPDATE kiriwrite_templates SET
4493                         filename                = \'' . $templatenewfilename . '\',
4494                         templatename            = \'' . $templatenewname . '\',
4495                         templatedescription     = \'' . $templatenewdescription . '\',
4496                         templatelayout          = \'' . $templatelayout . '\',
4497                         datemodified            = \'' . $templatenewdate . '\'
4498                         WHERE filename          = \'' . $templatefilename . '\'
4499                 ') or die(kiriwrite_error("templatedatabaseinvalidformat"));
4500                 $string_handle->execute();
4501
4502                 # Convert the following values so that display
4503
4504                 $templatenewname        = kiriwrite_convert($templatenewname, "normal_display");
4505
4506                 # Append a link so that the user can return to the templates list.
4507
4508                 $pagedata = $pagedata . "<h2>Edit Template</h2>";
4509                 $pagedata = $pagedata . "The selected template called '" . $templatenewname . "' was edited.<p>";
4510                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=template\">Return to the templates list.</a>";
4511
4512         } else {
4513
4514                 # Load the SQLite database.
4515
4516                 my $templatefilename_sql        = kiriwrite_convert($templatefilename, "kiriwrite");
4517
4518                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
4519                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates where filename = \'' . $templatefilename_sql . '\' limit 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
4520                 $string_handle->execute();
4521
4522                 # Check if there is a result from the SQL query made (meaning
4523                 # that the template exists).
4524
4525                 my $template_found = 0;
4526                 my @database_template;
4527
4528                 while (@database_template = $string_handle->fetchrow_array()){
4529
4530                         # The template has been found, so set the template
4531                         # found value to 1 so it doesn't return an error.
4532
4533                         $template_found = 1;
4534
4535                 }
4536
4537                 if ($template_found eq 0){
4538
4539                         # The template was not found (doesn't exist) so
4540                         # return an error.
4541
4542                         kiriwrite_error("templatedoesnotexist");
4543
4544                 }
4545
4546                 # Execute the query and get the information again.
4547
4548                 $string_handle->execute();
4549                 @database_template      = $string_handle->fetchrow_array();
4550
4551                 # Get the values from the query results.
4552
4553                 my $template_filename           = $database_template[0];
4554                 my $template_name               = $database_template[1];
4555                 my $template_description        = $database_template[2];
4556                 my $template_layout             = $database_template[3];
4557                 my $template_modified           = $database_template[4];
4558
4559                 # Convert the values that are going to be displayed.
4560
4561                 $template_filename      = kiriwrite_convert($template_filename, "normal_display");
4562                 $template_name          = kiriwrite_convert($template_name, "normal_display");
4563                 $template_description   = kiriwrite_convert($template_description, "normal_display");
4564                 $template_layout        = kiriwrite_convert($template_layout, "normal_display");
4565
4566                 # Write out the form for editing an template with the current template
4567                 # settings put into the correct place.
4568
4569                 $pagedata = $pagedata . "<h2>Edit Template</h2>";
4570                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
4571                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
4572                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
4573                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
4574                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"template\" value=\"" . $template_filename . "\">";
4575                 $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">";
4576                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
4577                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Name:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newname\" value=\"" . $template_name . "\" maxlength=\"512\" size=\"64\"></td></tr>";
4578                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Description:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newdescription\" value=\"" . $template_description . "\" maxlength=\"512\" size=\"64\"></td></tr>";
4579                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filename:</td><td class=\"tablecell2\"><input type=\"text\" name=\"newfilename\" maxlength=\"64\" size=\"32\" value=\"" . $template_filename . "\"></td></tr>";
4580                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Template Layout:</td><td class=\"tablecell2\"><textarea rows=\"15\" cols=\"50\" name=\"newlayout\" wrap=off>" . $template_layout . "</textarea></td></tr>";
4581                 $pagedata = $pagedata . "</table><br>";
4582                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Update template settings\"> | <input type=\"reset\" value=\"Restore current settings\"> | <a href=\"kiriwrite.cgi?mode=template\">Return to the templates list.</a>";
4583                 $pagedata = $pagedata . "</form>";
4584
4585         }
4586
4587         return $pagedata;
4588
4589 }
4590
4591 sub kiriwrite_template_delete{
4592 #################################################################################
4593 # kiriwrite_template_delete: Delete a template from the template folder.        #
4594 #                                                                               #
4595 # Usage:                                                                        #
4596 #                                                                               #
4597 # kiriwrite_template_delete(filename, confirm);                                 #
4598 #                                                                               #
4599 # filename      Specifies the filename of the database to delete.               #
4600 # confirm       Confirms the action to delete a template.                       #
4601 #################################################################################
4602
4603         # Get the parameters that were passed to the subroutine.
4604
4605         my ($template_filename, $template_confirm) = @_;
4606
4607         if (!$template_confirm){
4608                 $template_confirm = 0;
4609         }
4610
4611         # Load the required Perl modules
4612         use DBI;
4613
4614         # Check the length of the variables.
4615         kiriwrite_variablecheck($template_filename, "maxlength", 64, 0);
4616         kiriwrite_variablecheck($template_confirm, "maxlength", 1, 0);
4617
4618         # Check if the template_name string is blank and if it is then
4619         # return an error (as the template_name string should not be
4620         # blank.
4621
4622         if (!$template_filename){
4623
4624                 # The template_filename string really is blank,
4625                 # so return an error saying that an empty
4626                 # filename was passed (to the subroutine).
4627
4628                 kiriwrite_error("templatefilenameblank");
4629
4630         }
4631
4632         # Check if the template_confirm string is blank and if it is, write
4633         # out a form asking the user to confirm the deletion.
4634
4635         if ($template_confirm eq 1){
4636
4637                 # The action to delete the template from the template database has
4638                 # been confirmed so delete the template.
4639
4640                 # Check if the template database exists and the file permissions
4641                 # are valid and return an error if they aren't.
4642
4643                 my $template_database_exists            = kiriwrite_fileexists("templates.db");
4644                 my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
4645
4646                 if ($template_database_exists eq 1){
4647
4648                         # the template database does not exist so return an error.
4649
4650                         kiriwrite_error("templatedatabasemissing");
4651
4652                 }
4653
4654                 if ($template_database_permissions eq 1){
4655
4656                         # The template database permissions are set incorrectly so
4657                         # return an error.
4658
4659                         kiriwrite_error("templatedatabaseinvalidpermissions");
4660
4661                 }
4662
4663                 # Load thw SQLite database.
4664
4665                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
4666
4667                 # Get the template name.
4668
4669                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1') or die(kiriwrite_error("templatedatabaseinvalidformat"));
4670                 $string_handle->execute();
4671
4672                 my @database_template_page      = $string_handle->fetchrow_array();
4673                 my $database_template_name      = $database_template_page[1];
4674
4675                 $database_template_name         = kiriwrite_convert($database_template_name, "normal_display");
4676
4677                 # Delete the selected template.
4678
4679                 $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\'');
4680                 $string_handle->execute();
4681
4682                 my $pagedata = "<h2>Template Deleted</h2>";
4683                 $pagedata = $pagedata . "The selected template called '" . $database_template_name . "' was deleted.";
4684                 $pagedata = $pagedata . "<br><br><a href=\"kiriwrite.cgi?mode=template\">Return to the templates list</a>";
4685
4686                 return $pagedata;
4687
4688         } elsif ($template_confirm eq 0) {
4689
4690                 # The template confirm value is 0 (previously blank and then set to 0), so
4691                 # write out a form asking the user to confirm the deletion of the template.
4692
4693                 # Check the templte database file exists and the permissions for the
4694                 # template database are valid.
4695
4696                 my $template_database_exists            = kiriwrite_fileexists("templates.db");
4697                 my $template_database_permissions       = kiriwrite_filepermissions("templates.db", 1, 1, 0);
4698
4699                 if ($template_database_exists eq 1){
4700
4701                         # The template database does not exist so return an error.
4702
4703                         kiriwrite_error("templatedatabasemissing");
4704
4705                 }
4706
4707                 if ($template_database_permissions eq 1){
4708
4709                         # The template database has invalid permissions set so return
4710                         # an error.
4711
4712                         kiriwrite_error("templatedatabaseinvalidpermissions");
4713
4714                 }
4715
4716                 # Load the SQLite database.
4717
4718                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=templates.db");
4719                 my $string_handle       = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1');
4720                 $string_handle->execute();
4721
4722                 # Check if a result had returned and return an error if no result
4723                 # was returned.
4724
4725                 my @template_data;
4726                 my $template_found = 0;
4727
4728                 while(@template_data = $string_handle->fetchrow_array()){
4729
4730                         # A template has been found so increment the counter.
4731
4732                         $template_found++;
4733                 }
4734
4735                 if ($template_found eq 0){
4736
4737                         # The template does not exist, so return an error.
4738                         kiriwrite_error("templatedoesnotexist");
4739
4740                 }
4741
4742                 # Get the template file information.
4743
4744                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_templates WHERE filename = \'' . $template_filename . '\' LIMIT 1');
4745                 $string_handle->execute();
4746                 @template_data = $string_handle->fetchrow_array();
4747
4748                 my $template_data_filename      = $template_data[0];
4749                 my $template_data_name          = $template_data[1];
4750
4751                 # Check if the template name is blank and if it is
4752
4753                 # Convert the strings so that display properly.
4754
4755                 $template_data_name     = kiriwrite_convert($template_data_name, "normal_display");
4756                 $template_data_name     = kiriwrite_convert($template_data_name, "normal_display");
4757
4758                 # Write out the confirmation form.
4759
4760                 my $pagedata = "<h2>Template Deletion</h2>";
4761                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
4762                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"template\">";
4763                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"template\" value=\"" . $template_filename ."\">";
4764                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
4765                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
4766                 $pagedata = $pagedata . "Are you sure you want to delete the template called '" . $template_data_name . "' (" . $template_data_filename . ")?<br><br>";
4767                 $pagedata = $pagedata . "<input type=\"submit\" name=\"submit\" value=\"Yes, delete the template\"> | <a href=\"kiriwrite.cgi?mode=template\">No, return to the template list.</a>";
4768
4769                 $pagedata = $pagedata . "</form>";
4770
4771                 return $pagedata;
4772
4773         } else {
4774
4775                         kiriwrite_error("invalidvariable");
4776
4777         }
4778
4779 }
4780
4781 sub kiriwrite_template_list{
4782 #################################################################################
4783 # kiriwrite_template_list: List the templates in the template folder.           #
4784 #                                                                               #
4785 # Usage:                                                                        #
4786 #                                                                               #
4787 # kiriwrite_template_list();                                                    #
4788 #################################################################################
4789
4790         # Load the module required for processing the XML configuration files.
4791
4792         use DBI;
4793
4794         # Define certain values for later.
4795
4796         my @database_template;
4797
4798         my $database_handle;
4799         my $string_handle;
4800
4801         my $template_filename           = "";
4802         my $template_name               = "";
4803         my $template_description        = "";
4804         my $template_data               = "";
4805
4806         my $template_count = 0;
4807
4808         my $template_style = 0;
4809         my $template_stylename = "";
4810
4811         my $pagedata = "";
4812         my $templatedata = "";
4813
4814         # Check if the template database exists and the permissions for it are
4815         # valid if the template database doesn't exist then write a message
4816         # saying it will be created when a template is added.
4817
4818         my $template_database_permissions = kiriwrite_filepermissions("templates.db", 1, 0, 1);
4819         my $template_database_exists      = kiriwrite_fileexists("templates.db");
4820
4821         if ($template_database_permissions eq 1){
4822
4823                 # The templates directory has invalid permissions so an
4824                 # error will be returned.
4825
4826                 kiriwrite_error("templatedatabaseinvalidpermissions");
4827
4828         }
4829
4830         if ($template_database_exists eq 1){
4831
4832                 $pagedata = "<h2>View Templates</h2>";
4833                 $pagedata = $pagedata .  "<div class=\"errorbox\">The template database doesn't exist and will be created when a template is added.</div>";
4834
4835                 return $pagedata;
4836
4837         }
4838
4839         # Place the table cell headings into the templatedata string.
4840
4841         $templatedata = "<table cellspacing=\"0\" cellpadding=\"5\"><tr><td class=\"tablecellheader\">Template Filename</td><td class=\"tablecellheader\">Template Name</td><td class=\"tablecellheader\">Template Description</td><td class=\"tablecellheader\">Options</td></tr>";
4842
4843         # Check if the database exists first before loading it.
4844
4845         if ($template_database_exists eq 1){
4846
4847         } else {
4848
4849                 # Load the SQLite database.
4850
4851                 $database_handle        = DBI->connect("dbi:SQLite:dbname=templates.db");
4852                 $string_handle          = $database_handle->prepare("SELECT * FROM kiriwrite_templates ORDER BY filename ASC") or die(kiriwrite_error("templatedatabaseinvalidformat"));
4853                 $string_handle->execute();
4854
4855                 # Process each template.
4856
4857                 while (@database_template = $string_handle->fetchrow_array()){
4858
4859                         # Get certain values from the array.
4860
4861                         $template_filename      = $database_template[0];
4862                         $template_name          = $database_template[1];
4863                         $template_description   = $database_template[2];
4864                         $template_data          = $database_template[3];
4865
4866                         # Convert the data into information that can be displayed.
4867
4868                         $template_filename      = kiriwrite_convert($template_filename, "normal_display");
4869                         $template_name          = kiriwrite_convert($template_name, "normal_display");
4870                         $template_description   = kiriwrite_convert($template_description, "normal_display");
4871                         $template_data          = kiriwrite_convert($template_data, "normal_display");
4872
4873                         # Check what style the row of table cells should be.
4874
4875                         if ($template_style eq 0){
4876
4877                                 $template_stylename = "tablecell1";
4878                                 $template_style = 1;
4879
4880                         } else {
4881
4882                                 $template_stylename = "tablecell2";
4883                                 $template_style = 0;
4884
4885                         }
4886
4887                         # Check if the template name and descriptions are blank and if
4888                         # they are then insert a message saying that there's no name
4889                         # or no description.
4890
4891                         if (!$template_name){
4892                                 $template_name = "<i>No Name</i>";
4893                         }
4894
4895                         if (!$template_description){
4896                                 $template_description = "<i>No Description</i>";
4897                         }
4898
4899                         # Check if there is no template data and if there isn't write
4900                         # a blank template message.
4901
4902                         if (!$template_data){
4903                                 $template_filename = $template_filename . " <i>[Blank Template]</i>";
4904                         }
4905
4906                         # Append the table row to the templatedata string.
4907
4908                         $templatedata = $templatedata . "<tr><td class=\"" . $template_stylename  . "\">" . $template_filename . "</td><td class=\"" . $template_stylename  . "\">" . $template_name . "</td><td class=\"" . $template_stylename  . "\">" . $template_description . "</td><td class=\"" . $template_stylename  . "\"><a href=\"kiriwrite.cgi?mode=template&action=edit&template=" . $template_filename . "\">Edit</a> <a href=\"kiriwrite.cgi?mode=template&action=delete&template=" . $template_filename . "\">Delete</a></td></tr>";
4909
4910                         # Increment the template counter.
4911
4912                         $template_count++;
4913
4914                 }
4915
4916         }
4917
4918         $templatedata = $templatedata . "</table>";
4919
4920         # Check if any templates are in the database and if there isn't
4921         # then write a message saying that there are no templates in the
4922         # database.
4923
4924         if ($template_count eq 0){
4925                 $templatedata = "<div class=\"errorbox\">There are no templates in the template database. To add a template click on the Add Template link.</div>";
4926         }
4927
4928         # Process the templatedata into pagedata.
4929
4930         $pagedata = "<h2>View Templates</h2>";
4931         $pagedata = $pagedata . $templatedata;
4932
4933         return $pagedata;
4934
4935 }
4936
4937 sub kiriwrite_database_add{
4938 #################################################################################
4939 # kiriwrite_database_add: Creates a new database.                               #
4940 #                                                                               #
4941 # Usage:                                                                        #
4942 #                                                                               #
4943 # kiriwrite_database_add(filename, name, description, [confirm]);               #
4944 #                                                                               #
4945 # filename      Specifies the filename for the database.                        #
4946 # name          Specifies a (friendly) name for the database.                   #
4947 # description   Specifies a description for the database.                       #
4948 # confirm       Confirms the action to create a database.                       #
4949 #################################################################################
4950
4951         # Get the variables passed from the subroutine.
4952
4953         my ($database_filename, $database_name, $database_description, $database_notes, $database_categories, $database_confirm) = @_;
4954
4955         # Load the perl modules for this subroutine.
4956
4957         use DBI;
4958
4959         # Check if the confirm value is blank and if it is then
4960         # set the confirm value to 0.
4961
4962         if (!$database_confirm){
4963
4964                 # The confirm value was blank so set the value to 0.
4965
4966                 $database_confirm = 0;
4967
4968         }
4969
4970
4971         if ($database_confirm eq 1){
4972
4973                 # The action to create a new database is confirmed.
4974
4975                 # Validate the database name and database descriptions.
4976
4977                 my $database_name_check_utf8            = kiriwrite_variablecheck($database_name, "utf8", 0, 0);
4978                 my $database_description_check_utf8     = kiriwrite_variablecheck($database_description, "utf8", 0, 0);
4979                 my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
4980                 my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
4981
4982                 # Convert the UTF8 strings before checking the length of the strings.
4983
4984                 $database_name                  = kiriwrite_utf8convert($database_name);
4985                 $database_description           = kiriwrite_utf8convert($database_description);
4986                 $database_notes                 = kiriwrite_utf8convert($database_notes);
4987                 $database_categories            = kiriwrite_utf8convert($database_categories);
4988
4989                 my $database_name_check_blank           = kiriwrite_variablecheck($database_name, "blank", 0, 1);
4990                 my $database_name_check_length          = kiriwrite_variablecheck($database_name, "maxlength", 256, 1);
4991                 my $database_description_check_length   = kiriwrite_variablecheck($database_description, "maxlength", 512, 1);
4992                 my $database_filename_check_length      = kiriwrite_variablecheck($database_filename, "maxlength", 64, 1);
4993                 my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
4994
4995                 # Check if values returned contains any values that would
4996                 # result in a specific error message being returned.
4997
4998                 if ($database_name_check_length eq 1){
4999
5000                         # The length of the database name is too long, so return an error.
5001                         kiriwrite_error("databasenametoolong");
5002
5003                 }
5004
5005                 if ($database_description_check_length eq 1){
5006
5007                         # The database description length is too long, so return an error.
5008                         kiriwrite_error("databasedescriptiontoolong");
5009
5010                 }
5011
5012                 if ($database_name_check_blank eq 1){
5013
5014                         # The database name is blank, so return an error.
5015                         kiriwrite_error("databasenameblank");
5016
5017                 }
5018
5019                 if ($database_filename_check_length eq 1){
5020
5021                         # The database filename is to long, so return an error.
5022                         kiriwrite_error("databasefilenametoolong");
5023
5024                 }
5025
5026                 if ($database_categories_check_length eq 1){
5027
5028                         # The database categories is too long, so return an error.
5029                         kiriwrite_error("databasecategoriestoolong");
5030
5031                 }
5032
5033                 # Check if the database filename is blank and if it is then
5034                 # generate a filename.
5035
5036                 if ($database_filename eq ""){
5037
5038                         # Filename is blank so generate a file name from
5039                         # the database name.
5040
5041                         $database_filename = kiriwrite_processfilename($database_name);
5042
5043                         # Check to make sure that the database filename really
5044                         # is valid.
5045
5046                         kiriwrite_variablecheck($database_filename, "filename", "", 0);
5047                         kiriwrite_variablecheck($database_filename, "maxlength", 64, 0);
5048
5049                         # Check if the database and database configuration file does
5050                         # not already exist.
5051
5052                         if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db'){
5053
5054                                 # A filename exists, so abort the script telling the user that those files exist.
5055                                 kiriwrite_error("fileexists");
5056
5057                         }
5058
5059                 } else {
5060
5061                         # Filename is not blank, so check if the filenames are already
5062                         # being used and if the actual filename itself is valid.
5063
5064                         # Check the filename to make sure the database and the database configuration file does not already exist.
5065
5066                         if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db' ){
5067
5068                                 # A filename exists, so abort the script telling the user that those files exist.
5069
5070                                 kiriwrite_error("fileexists");
5071
5072
5073                         }
5074
5075                         # Check to make sure the database filename itself really is
5076                         # valid.
5077
5078                         kiriwrite_variablecheck($database_filename, "filename", "", 0);
5079                         kiriwrite_variablecheck($database_filename, "maxlength", 64, 0);
5080
5081                 }
5082
5083                 # Convert certain data so that the SQL query doesn't break.
5084
5085                 my $database_name_final = $database_name;
5086                 $database_name          = kiriwrite_convert($database_name, "kiriwrite");
5087                 $database_description   = kiriwrite_convert($database_description, "kiriwrite");
5088                 $database_categories    = kiriwrite_convert($database_categories, "kiriwrite");
5089
5090                 # Populate the database with the infomration and page tables.
5091
5092                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . ".db");
5093                 my $string_handle       = $database_handle->prepare('CREATE TABLE kiriwrite_database_info(
5094                         name varchar(256) primary key,
5095                         description varchar(512),
5096                         notes text,
5097                         categories varchar(512),
5098                         kiriwrite_version_major int(4),
5099                         kiriwrite_version_minor int(4),
5100                         kiriwrite_version_revision int(4)
5101                 )');
5102                 $string_handle->execute();
5103
5104                 $string_handle  = $database_handle->prepare('CREATE TABLE kiriwrite_database_pages(
5105                         filename varchar(256) primary key,
5106                         pagename varchar(512),
5107                         pagedescription varchar(512),
5108                         pagesection varchar(256),
5109                         pagetemplate varchar(64),
5110                         pagedata text,
5111                         pagesettings int(1),
5112                         lastmodified datetime
5113                 )');
5114                 $string_handle->execute();
5115
5116                 # Add an entry to the kiriwrite_database_info table.
5117
5118                 $string_handle = $database_handle->prepare('INSERT INTO kiriwrite_database_info values(
5119                         \'' . $database_name . '\',
5120                         \'' . $database_description . '\',
5121                         \'' . $database_notes . '\',
5122                         \'' . $database_categories . '\',
5123                         \'' . $kiriwrite_version{"major"} . '\',
5124                         \'' . $kiriwrite_version{"minor"} . '\',
5125                         \'' . $kiriwrite_version{"revision"} . '\'
5126                 )');
5127                 $string_handle->execute();
5128
5129                 $database_name_final = kiriwrite_convert($database_name_final, "normal_display");
5130
5131                 my $pagedata    = "<h2>Add Database</h2>";
5132                 $pagedata       = $pagedata . "Database '" . $database_name_final  . "' has been created.<br><br>\r\n";
5133                 $pagedata       = $pagedata . "<a href=\"kiriwrite.cgi?mode=db\">Return to database list</a>";
5134
5135                 return $pagedata;
5136
5137         }
5138
5139         # There is confirm value is not 1, so write a form for creating a database to
5140         # store pages in.
5141
5142         my $pagedata    = "<h2>Add Database</h2>\r\n";
5143
5144         $pagedata       = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
5145         $pagedata       = $pagedata . "\t\t\t<table cellpadding=\"5\" cellspacing=\"0\">\r\n";
5146         $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"mode\" value=\"db\">\r\n";
5147         $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"action\" value=\"new\">\r\n";
5148         $pagedata       = $pagedata . "\t\t<input type=\"hidden\" name=\"confirm\" value=\"1\">\r\n";
5149         $pagedata       = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
5150         $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database name</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"256\" name=\"databasename\"></td></tr>";
5151         $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database description</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"512\" name=\"databasedescription\"></td></tr>";
5152         $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database notes</td><td class=\"tablecell2\"><textarea name=\"databasenotes\" wrap=\"off\" cols=\"50\" rows=\"10\"></textarea></td></tr>";
5153         $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database categories</td><td class=\"tablecell2\"><input type=\"text\" size=\"64\" maxlength=\"512\" name=\"databasecategories\"></td></tr>";
5154         $pagedata       = $pagedata . "<tr><td class=\"tablecell1\">Database filename</td><td class=\"tablecell2\"><input type=\"text\" size=\"32\" maxlength=\"64\" name=\"databasefilename\"><br />
5155                 <ul>
5156                         <li>Leave the filename blank to automatically generate a filename.</li>
5157                         <li>Don't include .db as it will be appended automatically.</li>
5158                         <li>The filename cannot be any more than 64 characters long.</li>
5159                         <li>The filename should only contain letters and numbers, no spaces.</li>
5160                 </ul>
5161         </td></tr>";
5162         $pagedata       = $pagedata . "\t\t\t</table>\r\n";
5163         $pagedata       = $pagedata . "\t\t\t<br />\r\n";
5164         $pagedata       = $pagedata . "\t\t\t<input type=\"submit\" value=\"Add Database\"> | <input type=\"reset\" value=\"Clear values\">";
5165         $pagedata       = $pagedata . "\t\t</form>\r\n";
5166
5167         # Exit the subroutine taking the data in the pagadata variable with it.
5168
5169         return $pagedata;
5170
5171 }
5172
5173 sub kiriwrite_database_edit{
5174 #################################################################################
5175 # kiriwrite_database_edit: Edits an database.                                   #
5176 #                                                                               #
5177 # Usage:                                                                        #
5178 #                                                                               #
5179 # kiriwrite_database_edit(filename, name, description, newfilename, newname,    #
5180 #                               newdescription, notes, categories, [confirm]);  #
5181 #                                                                               #
5182 # filename              Specifies the filename of the database.                 #
5183 # name                  Specifies the name of the database.                     #
5184 # description           Specifies the description of the database.              #
5185 # newfilename           Specifies the new filename of the database.             #
5186 # newname               Specifies the new name of the database.                 #
5187 # newdescription        Specifies the new description of the database.          #
5188 # notes                 Specifies the new notes of the database.                #
5189 # categories            Specifies the new categories of the database.           #
5190 # confirm               Confirms the action to edit a database.                 #
5191 #################################################################################
5192
5193         # First, get all the variables passed to the subroutine.
5194
5195         my ($database_shortname, $database_name, $database_description, $database_newfilename, $database_newname, $database_newdescription, $database_notes, $database_categories, $database_confirm) = @_;
5196
5197         # Load the needed Perl modules.
5198
5199         use DBI;
5200
5201         # Check if the database confirm value is blank and if it is
5202         # set the confirm value to 0.
5203
5204         if (!$database_confirm){
5205
5206                 $database_confirm = 0;
5207
5208         }
5209
5210         # Check if the confirm variable has a value in it, if it has, check again to make sure it really is the correct value (Perl moans
5211         # if $database_confirm was used directly).
5212
5213         if ($database_confirm eq 1){
5214
5215                 # Check if the database exists before trying to edit it.
5216
5217                 my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
5218
5219                 if ($database_exists eq 1){
5220
5221                         # The database does not exist so return an error.
5222
5223                         kiriwrite_error("databasemissingfile");
5224
5225                 }
5226
5227                 # Check if the new data passes the validation tests below. First, check the length of the variables.
5228
5229                 my $database_name_check_utf8            = kiriwrite_variablecheck($database_newname, "utf8", 0, 0);
5230                 my $database_description_check_utf8     = kiriwrite_variablecheck($database_newdescription, "utf8", 0, 0);
5231                 my $database_notes_check_utf8           = kiriwrite_variablecheck($database_notes, "utf8", 0, 0);
5232                 my $database_categories_check_utf8      = kiriwrite_variablecheck($database_categories, "utf8", 0, 0);
5233
5234                 # Convert the UTF8 strings to make sure their length is accurate.
5235
5236                 $database_newname               = kiriwrite_utf8convert($database_newname);
5237                 $database_newdescription        = kiriwrite_utf8convert($database_newdescription);
5238                 $database_notes                 = kiriwrite_utf8convert($database_notes);
5239                 $database_categories            = kiriwrite_utf8convert($database_categories);
5240
5241                 # Check if the database filename given is valid and return an error
5242                 # if it isn't.
5243
5244                 kiriwrite_variablecheck($database_shortname, "filename", "", 0);
5245
5246                 # Preform the following tests.
5247
5248                 my $database_filename_check_length      = kiriwrite_variablecheck($database_newfilename, "maxlength", 64, 1);
5249                 my $database_filename_letnum            = kiriwrite_variablecheck($database_newfilename, "filename", 0, 0);
5250                 my $database_name_check_length          = kiriwrite_variablecheck($database_newname, "maxlength", 256, 1);
5251                 my $database_description_check_length   = kiriwrite_variablecheck($database_newdescription, "maxlength", 512, 1);
5252                 my $database_categories_check_length    = kiriwrite_variablecheck($database_categories, "maxlength", 512, 1);
5253                 my $database_name_check_blank           = kiriwrite_variablecheck($database_newname, "blank", 0, 1);
5254
5255                 # Check if the data is valid and return a specific error if it doesn't.
5256
5257                 if ($database_name_check_length eq 1){
5258
5259                         # The length of the database name is too long, so return an error.
5260                         kiriwrite_error("databasenametoolong");
5261
5262                 }
5263
5264                 if ($database_description_check_length eq 1){
5265
5266                         # The database description length is too long, so return an error.
5267                         kiriwrite_error("databasedescriptiontoolong");
5268
5269                 }
5270
5271                 if ($database_name_check_blank eq 1){
5272
5273                         # The database name is blank, so return an error.
5274                         kiriwrite_error("databasenameblank");
5275
5276                 }
5277
5278                 if ($database_filename_check_length eq 1){
5279
5280                         # The database filename is too long, so return an error.
5281                         kiriwrite_error("databasefilenametoolong");
5282
5283                 }
5284
5285                 if ($database_categories_check_length eq 1){
5286
5287                         # The database categories is too long, so return an error.
5288                         kiriwrite_error("databasecategoriestoolong");
5289
5290                 }
5291
5292                 # Check the permissions of the database file to see if it is valid
5293                 # and return an error if it isn't.
5294
5295                 my $database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', 1, 1, 1);
5296
5297                 if ($database_file_permissions eq 1){
5298
5299                         # The database file itself has invalid permissions.
5300
5301                         kiriwrite_error("databaseinvalidpermissions");
5302
5303                 }
5304
5305                 # Check if the old and new filenames have changed, if they have then rename the database file.
5306
5307                 my $pagedata;
5308
5309                 $pagedata = "<h2>Edit Database</h2>";
5310
5311                 if ($database_shortname ne $database_newfilename){
5312
5313                         # Old name does not match with the new filename, so rename the database file.
5314
5315                         # Check if a database with the same shortname already exists, if it does then return with an error.
5316
5317                         if (-e $kiriwrite_config{"directory_data_db"} . '/' . $database_newfilename . '.db'){
5318                                 kiriwrite_error("databasealreadyexists");
5319                         }
5320
5321                         # Change the database filename.
5322
5323                         rename($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', $kiriwrite_config{"directory_data_db"} . '/' . $database_newfilename . '.db');
5324                         unlink($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
5325
5326                         # Set the filename to the new filename.
5327
5328                         $database_shortname = $database_newfilename;
5329
5330                 }
5331
5332                 # Load the SQLite database.
5333
5334                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . ".db");
5335
5336                 # Convert the UTF8 strings so that they can be properly updated.
5337
5338                 $database_name                  = kiriwrite_utf8convert($database_name);
5339                 $database_description           = kiriwrite_utf8convert($database_description);
5340
5341                 # Convert the strings that are going to put into the database so that
5342                 # the database query doesn't break.
5343
5344                 $database_name                  = kiriwrite_convert($database_name, "kiriwrite");
5345                 $database_newname               = kiriwrite_convert($database_newname, "kiriwrite");
5346                 $database_description           = kiriwrite_convert($database_description, "kiriwrite");
5347                 $database_newdescription        = kiriwrite_convert($database_newdescription, "kiriwrite");
5348
5349                 my $string_handle       = $database_handle->prepare('UPDATE kiriwrite_database_info SET name = \'' . $database_newname . '\', description = \'' . $database_newdescription . '\', notes = \'' . $database_notes . '\', categories = \'' . $database_categories . '\' WHERE name = \'' . $database_name . '\' AND description = \'' . $database_description . '\'') or kiriwrite_error("databasefileinvalid");
5350                 $string_handle->execute();
5351
5352                 # Convert a string so that it can be displayed properly.
5353
5354                 $database_newname = kiriwrite_convert($database_newname, "normal_display");
5355
5356                 # Write out a message saying that the database has been updated.
5357
5358                 $pagedata = $pagedata . "Database '" . $database_newname . "' updated.<br>";
5359                 $pagedata = $pagedata . "<br>\r\n<a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>";
5360
5361                 return $pagedata;
5362
5363         } else {
5364
5365                 # Check if the database filename given is valid and return an error
5366                 # if it isn't.
5367
5368                 kiriwrite_variablecheck($database_shortname, "filenameindir", "", 0);
5369
5370                 # Check if the database exists before trying to edit it.
5371
5372                 my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db');
5373
5374                 if ($database_exists eq 1){
5375
5376                         # The database does not exist so return an error.
5377
5378                         kiriwrite_error("databasemissingfile");
5379
5380                 }
5381
5382
5383                 # Check the permissions of the database file to see if it is valid
5384                 # and return an error if it isn't.
5385
5386                 my $database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . '.db', 1, 0, 1);
5387
5388                 if ($database_file_permissions eq 1){
5389
5390                         # The database file itself has invalid permissions.
5391
5392                         kiriwrite_error("databaseinvalidpermissions");
5393
5394                 }
5395
5396                 # Load the SQLite database.
5397
5398                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_shortname . ".db");
5399                 my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1") or kiriwrite_error("databasefileinvalid");
5400                 $string_handle->execute();
5401                 my @database_info               = $string_handle->fetchrow_array();
5402
5403                 # Get the values needed from the kiriwrite_database_info table.
5404
5405                 my $database_oldname            = $database_info[0];
5406                 my $database_olddescription     = $database_info[1];
5407                 my $database_notes              = $database_info[2];
5408                 my $database_categories         = $database_info[3];
5409
5410                 # Convert the values in the kieiwrite format into the format that can be understood
5411                 # with a web browser.
5412
5413                 $database_oldname               = kiriwrite_convert($database_oldname, "normal_display");
5414                 $database_olddescription        = kiriwrite_convert($database_olddescription, "normal_display");
5415                 $database_notes                 = kiriwrite_convert($database_notes, "normal_display");
5416                 $database_categories            = kiriwrite_convert($database_categories, "normal_display");
5417
5418                 # Print out the form for editing a database's settings.
5419
5420                 my $pagedata = "<h2>Edit Database '" . $database_oldname . "'</h2>";
5421                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
5422                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"db\">";
5423                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
5424                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"database\" value=\"" . $database_shortname . "\">";
5425                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"yes\">";
5426                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"olddatabasename\" value=\"" . $database_oldname . "\">";
5427                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"olddatabasedescription\" value=\"" . $database_olddescription . "\">";
5428                 $pagedata = $pagedata . "<table cellspacing=\"0\" cellpadding=\"5\">\r\n";
5429                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
5430                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database name</td><td class=\"tablecell2\"><input type=\"text\" name=\"databasename\" value=\"" . $database_oldname . "\" maxlength=\"256\" size=\"64\"></td></tr>";
5431                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database description</td><td class=\"tablecell2\"><input name=\"databasedescription\" maxlength=\"512\" size=\"64\" value=\"" . $database_olddescription . "\"></td></tr>";
5432                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database notes</td><td class=\"tablecell2\"><textarea name=\"databasenotes\" cols=\"50\" rows=\"10\" wrap=\"off\">" . $database_notes . "</textarea></td></tr>";
5433                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database categories</td><td class=\"tablecell2\"><input name=\"databasecategories\"  value=\"" . $database_categories . "\"  size=\"64\" maxlength=\"512\"></td></tr>";
5434                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database filename</td><td class=\"tablecell2\"><input name=\"databasefilename\" maxlength=\"64\" size=\"64\" value=\"" . $database_shortname . "\"></td></tr>";
5435                 $pagedata = $pagedata . "</table><p />";
5436
5437                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit settings\" /> | <input type=\"reset\" value=\"Reset settings\" />";
5438                 $pagedata = $pagedata . "</form>";
5439                 return $pagedata;
5440
5441         }
5442
5443         # The interpreter should not be here. So return an error saying invalid variable.
5444
5445         kiriwrite_error("invalidvariable");
5446
5447 }
5448
5449 sub kiriwrite_database_delete{
5450 #################################################################################
5451 # kiriwrite_database_delete: Deletes an database.                               #
5452 #                                                                               #
5453 # Usage:                                                                        #
5454 #                                                                               #
5455 # kiriwrite_database_delete(filename, [confirm]);                               #
5456 #                                                                               #
5457 # filename      Specifies the filename for the database to be deleted.          #
5458 # confirm       Confirms the action to delete a database.                       #
5459 #################################################################################
5460
5461         my ($database_filename, $database_confirm) = @_;
5462
5463         # Load the CGI module and the XML::Simple module for this subroutine.
5464
5465         use DBI;
5466
5467         # Check if the confirm value is blank and if it is then set the
5468         # confirm value to 0.
5469
5470         if (!$database_confirm){
5471
5472                 $database_confirm = 0;
5473
5474         }
5475
5476         # Check if the database exists before trying to edit it.
5477
5478         my $database_exists     = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
5479
5480         if ($database_exists eq 1){
5481
5482                 # The database does not exist so return an error.
5483
5484                 kiriwrite_error("databasemissingfile");
5485
5486         }
5487
5488         # Check if the database filename given is valid and return an error
5489         # if it isn't.
5490
5491         kiriwrite_variablecheck($database_filename, "filename", "", 0);
5492
5493         # Check if the request to delete a database has been confirmed. If it has,
5494         # then delete the database itself.
5495
5496         if ($database_confirm eq 1){
5497                 # There is a value in the confirm variable of the HTTP query.
5498
5499                 # Before deleting, check the permissions of the database file.
5500
5501                 my $deleted_database_file_permissions                   = 0;
5502
5503                 my $pagedata = "";
5504
5505                 $deleted_database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db', 1, 1, 1);
5506
5507                 if ($deleted_database_file_permissions eq 1){
5508
5509                         # The database file itself has invalid permissions.
5510
5511                         kiriwrite_error("databaseinvalidpermissions");
5512
5513                 }
5514
5515                 # Load the SQLite database to get the database name.
5516
5517                 my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
5518                 my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1");
5519                 $string_handle->execute;
5520                 my @database_info       = $string_handle->fetchrow_array();
5521
5522                 my $database_name = $database_info[0];
5523                 $database_name = kiriwrite_convert($database_name, "normal_display");
5524
5525                 # Untaint the database filename given.
5526
5527                 ($database_filename) = $database_filename =~ /^([a-zA-Z0-9.]+)$/;
5528
5529                 # Delete the database file.
5530
5531                 unlink($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
5532
5533                 # Write a message saying that the database has been deleted.
5534
5535                 $pagedata = "<h2>Database Deleted</h2>";
5536                 $pagedata = $pagedata . "Database '" . $database_name . "' was deleted.<br />\r\n";
5537
5538                 $pagedata = $pagedata . "<br><a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>";
5539
5540                 return $pagedata;
5541
5542         }
5543
5544         # The action has not been confirmed, so write out a form asking the
5545         # user to confirm.
5546
5547         # Check the permissions of the database file to see if they are valid
5548         # and return an error if it isn't.
5549
5550         my $delete_database_file_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db', 1, 1, 1);
5551
5552         if ($delete_database_file_permissions eq 1){
5553
5554                 # The database file itself has invalid permissions.
5555
5556                 kiriwrite_error("databaseinvalidpermissions");
5557
5558         }
5559
5560         # Load the SQLite database to get the database name.
5561
5562         my $database_handle     = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database_filename . '.db');
5563         my $string_handle       = $database_handle->prepare("SELECT * FROM kiriwrite_database_info LIMIT 1");
5564         $string_handle->execute;
5565         my @database_info       = $string_handle->fetchrow_array();
5566
5567         # Convert the database name so that it can be displayed properly.
5568
5569         my $database_name = $database_info[0];
5570         $database_filename      = kiriwrite_convert($database_filename, "normal_display");
5571         $database_name          = kiriwrite_convert($database_name, "normal_display");
5572
5573         # Write out the form to ask the user to confirm the deletion of the
5574         # selected database.
5575
5576         my $pagedata = "<h2>Database Deletion</h2>";
5577         $pagedata = $pagedata . "\t\tAre you sure you want to delete '". $database_name . "'\?<br><br>";
5578         $pagedata = $pagedata . "\t\t<form action=\"kiriwrite.cgi\" method=\"POST\">\r\n";
5579         $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"mode\" value=\"db\">";
5580         $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"action\" value=\"delete\">";
5581         $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"database\" value=\"" . $database_filename . "\">";
5582         $pagedata = $pagedata . "\t\t<input type=\"hidden\" name=\"confirm\" value=\"1\">";
5583         $pagedata = $pagedata . "\t\t<input type=\"submit\" value=\"Delete Database\"> | <a href=\"kiriwrite.cgi?mode=db\">Return to database list.</a>";
5584         $pagedata = $pagedata . "\t\t</form>\r\n";
5585
5586         return $pagedata;
5587
5588 }
5589
5590 sub kiriwrite_database_list{
5591 #################################################################################
5592 # kiriwrite_database_list: Lists the databases available.                       #
5593 #                                                                               #
5594 # Usage:                                                                        #
5595 #                                                                               #
5596 # kiriwrite_database_list();                                                    #
5597 #################################################################################
5598
5599         # Load the following Perl modules.
5600         use DBI;
5601
5602         # Check the directory to make sure the permissions are settings are valid
5603         # and return an error if the permission settings are invalid.
5604
5605         my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
5606
5607         if ($data_directory_permissions eq 1){
5608
5609                 # The data directory has invalid permissions set, so return an error.
5610
5611                 kiriwrite_error("datadirectoryinvalidpermissions");
5612
5613         }
5614
5615         # Open the directory and get the list of all files ending with .xml and
5616         # put them into the data_directory array.
5617
5618         opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
5619         my @data_directory = grep /m*\.db/, readdir(DATADIR);
5620         closedir(DATADIR);
5621
5622         # Declare the following variables that are going to be used before using
5623         # the foreach function.
5624
5625         my $pagedata = "";
5626         my $database_count = 0;
5627         my $database_handle = "";
5628         my $database_filename = "";
5629         my $database_filename_friendly = "";
5630         my $database_filename_length = 0;
5631         my $database_permissions = "";
5632         my $data_file = "";
5633         my $string_handle = "";
5634         my @database_info;
5635         my $table_style = 0;
5636         my $table_style_name = "";
5637         my $permissions_warning = 0;
5638         my $permissions_list = "";
5639         my $invalid_warning = 0;
5640         my $invalid_list = "";
5641
5642         # Begin creating the table for the list of databases.
5643
5644         $pagedata = "<h2>Database List</h2>\r\n";
5645
5646         $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\"><tr><td class=\"tablecellheader\">Database Name</td><td class=\"tablecellheader\">Database Description</td><td class=\"tablecellheader\">Options</td></tr>\r\n";
5647
5648         foreach $data_file (@data_directory){
5649                 # Check the database file permissions before opening it.
5650
5651                 $database_filename = $kiriwrite_config{"directory_data_db"} . '/' . $data_file;
5652                 $database_permissions = kiriwrite_filepermissions($database_filename, 1, 0, 0);
5653
5654                 if ($database_permissions eq 1){
5655                         $permissions_warning = 1;
5656                         $permissions_list = $permissions_list . $data_file . "<br>\r\n";
5657                         next;
5658                 }
5659
5660                 # Load the SQLite database.
5661
5662                 $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
5663
5664                 # Query the SQLite database or return an error (meaning that the database is in
5665                 # a invalid format).
5666
5667                 $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or (
5668                         $invalid_list = $invalid_list . $data_file . "<br>\r\n",
5669                         $invalid_warning = 1,
5670                         next
5671                 );
5672
5673                 $string_handle->execute();
5674                 @database_info = $string_handle->fetchrow_array();
5675
5676                 # Check the style to be used with.
5677
5678                 if ($table_style eq 0){
5679
5680                         # Use the first style and set the style value
5681                         # to use the next style, the next time the
5682                         # if statement is checked.
5683
5684                         $table_style_name = "tablecell1";
5685                         $table_style = 1;
5686                 } else {
5687
5688                         # Use the second style and set the style
5689                         # value to use the first style, the next
5690                         # time if statement is checked.
5691
5692                         $table_style_name = "tablecell2";
5693                         $table_style = 0;
5694                 }
5695
5696                 $database_info[0] = kiriwrite_convert($database_info[0], "normal_display");
5697                 $database_info[1] = kiriwrite_convert($database_info[1], "normal_display");
5698
5699                 # Create a friendly name for the database.
5700
5701                 $database_filename_length = length($data_file);
5702                 $database_filename_friendly = substr($data_file, 0, $database_filename_length - 3);
5703
5704                 # Append the database information to the table.
5705
5706                 $pagedata = $pagedata . "<tr><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_filename_friendly . "\">" . $database_info[0] . "</a></td><td class=\"" . $table_style_name . "\">" . $database_info[1] . "</td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=db&action=edit&&database=" . $database_filename_friendly . "\">Edit</a> <a href=\"kiriwrite.cgi?mode=db&action=delete&database=" . $database_filename_friendly . "\">Delete</a> <a href=\"kiriwrite.cgi?mode=compile&action=compile&type=single&database=" . $database_filename_friendly . "\">Compile</a></td></tr>\r\n";
5707
5708                 $database_count++;
5709
5710         }
5711
5712         $pagedata = $pagedata . "</table>\r\n<br />";
5713
5714         # Check if there are no valid databases are if there is no
5715         # valid databases then write a message saying that no
5716         # valid databases are available.
5717
5718         if ($database_count eq 0){
5719
5720                 #
5721
5722                 $pagedata = "<h2>Database List</h2><p>";
5723                 $pagedata = $pagedata . "<div class=\"errorbox\">There are no databases that can be used. To create a database click on the Add Database link.</div><p>";
5724
5725         }
5726
5727         # Check if any databases with problems have appeared and if they
5728         # have, print out a message saying which databases have problems.
5729
5730         if ($permissions_warning eq 1){
5731
5732                 $pagedata = $pagedata . "<h4>Databases with invalid permissions</h4>";
5733                 $pagedata = $pagedata . "The following databases have invalid permissions set:<br><br>";
5734                 $pagedata = $pagedata . $permissions_list;
5735
5736         }
5737
5738         if ($invalid_warning eq 1){
5739
5740                 $pagedata = $pagedata . "<h4>Databases with invalid formats</h4>";
5741                 $pagedata = $pagedata . "The following databases are in a invalid format:<br><br>";
5742                 $pagedata = $pagedata . $invalid_list;
5743
5744         }
5745
5746         return $pagedata;       # Return to the main part of the script with the processed information.
5747
5748 }
5749
5750
5751 sub kiriwrite_filter_list{
5752 #################################################################################
5753 # kiriwrite_filter_list: Lists the filters that will be used when compiling a   #
5754 # webpage.                                                                      #
5755 #                                                                               #
5756 # Usage:                                                                        #
5757 #                                                                               #
5758 # kiriwrite_filter_list();                                                      #
5759 #################################################################################
5760
5761         # Load the needed Perl modules.
5762
5763         use DBI;
5764
5765         # Check if the filters database exists and the
5766         # permissions for the filters database are
5767         # valid.
5768
5769         my $database_exists             = kiriwrite_fileexists("filters.db");
5770         my $database_permissions        = kiriwrite_filepermissions("filters.db", 1, 0, 0);
5771         my $filtersdb_notexist = 0;
5772
5773         if ($database_exists eq 1){
5774
5775                 # The filters database does not exist so
5776                 # set the value for the filters database
5777                 # not existing to 1.
5778
5779                 $filtersdb_notexist = 1;
5780
5781         }
5782
5783         if ($database_permissions eq 1 && $database_exists ne 1){
5784
5785                 # The filters database has invalid
5786                 # permissions set, so return an error.
5787
5788                 kiriwrite_error("filtersdbpermissions");
5789
5790         }
5791
5792         # Define some variables required for processing the filters list.
5793
5794         my @database_filters;
5795         my $database_handle;
5796         my $string_handle;
5797         my $pagedata = "";
5798         my $filterdata = "";
5799         my $filterswarning = "";
5800         my $filter_id;
5801         my $filter_id_out;
5802         my $filter_find;
5803         my $filter_find_out;
5804         my $filter_replace;
5805         my $filter_replace_out;
5806         my $filter_count = 0;
5807         my $filter_priority;
5808         my $filter_priority_out;
5809         my $filter_style = 0;
5810         my $filter_find_blank = 0;
5811         my $filter_style_name = "";
5812
5813         $pagedata = $pagedata . "<h2>View Filters</h2>";
5814
5815         # If the filters database exists then get the list of filters,
5816         # otherwise write a message saying that the filters database
5817         # does not exist and will be created when a filter is added.
5818
5819         if ($filtersdb_notexist eq 0){
5820
5821                 # Get the SQLite database and get the filters ordered
5822                 # by priority.
5823
5824                 $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
5825                 $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY priority ASC') or kiriwrite_error("filtersdbinvalidformat");
5826                 $string_handle->execute();
5827
5828                 $filterdata = $filterdata . "<table cellspacing=\"0\" cellpadding=\"5\">";
5829                 $filterdata = $filterdata . "<tr><td class=\"tablecellheader\">Priority</td><td class=\"tablecellheader\">Find Setting</td><td class=\"tablecellheader\">Replace Setting</td><td class=\"tablecellheader\">Options</td></tr>";
5830
5831                 while (@database_filters = $string_handle->fetchrow_array()){
5832
5833                         # Get the values from the from the array.
5834
5835                         $filter_id              = $database_filters[0];
5836                         $filter_priority        = $database_filters[1];
5837                         $filter_find            = $database_filters[2];
5838                         $filter_replace         = $database_filters[3];
5839
5840                         # Convert the values into values that can be displayed.
5841
5842                         $filter_id_out          = kiriwrite_convert($filter_id, "normal_display");
5843                         $filter_priority_out    = kiriwrite_convert($filter_priority, "normal_display");
5844                         $filter_find_out        = kiriwrite_convert($filter_find, "normal_display");
5845                         $filter_replace_out     = kiriwrite_convert($filter_replace, "normal_display");
5846
5847                         # Check which style should be used.
5848
5849                         if ($filter_style eq 0){
5850
5851                                 $filter_style_name = "tablecell1";
5852                                 $filter_style = 1;
5853
5854                         } else {
5855
5856                                 $filter_style_name = "tablecell2";
5857                                 $filter_style = 0;
5858
5859                         }
5860
5861                         # Check if the replace filter is blank and if it is
5862                         # then say no replace setting is given.
5863
5864                         if (!$filter_replace){
5865
5866                                 # No replace filter is specified, so write a message
5867                                 # saying that there is no replace filter.
5868
5869                                 $filter_replace_out = "<i>Replace filter is blank.</i>";
5870
5871                         }
5872
5873                         # Check if the find filter is blank.
5874
5875                         if (!$filter_find && $filter_find_blank eq 0){
5876
5877                                 # No find filter is specified, So write a message saying
5878                                 # that one of your find filters is blank and needs to be
5879                                 # fixed.
5880
5881                                 $filterdata = "<b>Warning</b>: One (or more) of your filters has a blank find filter and needs to be fixed.<br><br>" . $filterdata;
5882
5883                         }
5884
5885                         # Add the filter to the list of filters in the database.
5886
5887                         $filterdata     = $filterdata . "<tr><td class=\"" . $filter_style_name . "\">" . $filter_priority_out . "</td><td class=\"" . $filter_style_name . "\">" . $filter_find_out . "</td><td class=\"" . $filter_style_name . "\">" . $filter_replace_out . "</td><td class=\"" . $filter_style_name . "\"><a href=\"\"><a href=\"kiriwrite.cgi?mode=filter&action=edit&filter=" . $filter_id_out . "\">Edit</a></a> <a href=\"kiriwrite.cgi?mode=filter&action=delete&filter=" . $filter_id_out . "\">Delete</a></td></tr>";
5888
5889                         $filter_count++;
5890
5891                 }
5892
5893                 $filterdata = $filterdata . "</table>";
5894
5895                 # Check if there are filters in the filters database and
5896                 # write a message if there isn't.
5897
5898                 if ($filter_count eq 0){
5899
5900                         # There are no filters in the filters database.
5901
5902                         $filterswarning = "There are no filters available in the filters database. To add a filter, click on the Add Filter link.";
5903
5904                 }
5905
5906         }
5907
5908         # Check if the database wasn't found and if it
5909         # wasn't then write a message saying that the
5910         # database will be created when a filter is
5911         # added.
5912
5913         if ($filtersdb_notexist eq 1){
5914
5915                 # The filters database doesn't exist so write
5916                 # a message.
5917
5918                 $filterswarning = "The filters database does not exist and will be created when a filter is added.";
5919
5920
5921         }
5922
5923         # Check if there is a warning message and if
5924         # there is then write that warning message
5925         # else write the list of filters.
5926
5927         if ($filterswarning){
5928
5929                 $pagedata = $pagedata . "<div class=\"errorbox\">";
5930                 $pagedata = $pagedata . $filterswarning;
5931                 $pagedata = $pagedata . "</div>";
5932
5933         } else {
5934
5935                 # The filters database exists so write out the
5936                 # list of filters.
5937
5938                 $pagedata = $pagedata . $filterdata;
5939
5940         }
5941
5942         return $pagedata;
5943
5944 }
5945
5946 sub kiriwrite_filter_add{
5947 #################################################################################
5948 # kiriwrite_filter_add: Adds a filter to the filter list.                       #
5949 #                                                                               #
5950 # Usage:                                                                        #
5951 #                                                                               #
5952 # kiriwrite_filter_add(filterfind, filterreplace, filterpriority,               #
5953 #                       filternotes, [confirm]);                                #
5954 #                                                                               #
5955 # filterfind            Specifies the new word(s) to find.                      #
5956 # filterreplace         Specifies the new word(s) to replace.                   #
5957 # filterpriority        Specifies the new priority to use.                      #
5958 # filternotes           Specifies the new notes to use.                         #
5959 # confirm               Confirms the action to add a filter.                    #
5960 #################################################################################
5961
5962         # Get the values that have been passed to the subroutine.
5963
5964         my ($filter_new_find, $filter_new_replace, $filter_new_priority, $filter_new_notes, $confirm) = @_;
5965
5966         # Load the needed Perl modules.
5967
5968         use DBI;
5969
5970         # Check the confirm value to make sure it is no more than
5971         # one character long.
5972
5973         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
5974
5975         # Define the page data value for later.
5976
5977         my $pagedata = "";
5978
5979         if (!$confirm){
5980
5981                 # The confirm value is undefined, so set the
5982                 # value of the confirm integer to '0'.
5983
5984                 $confirm = 0;
5985
5986         }
5987
5988         if ($confirm eq 1){
5989
5990                 # The confirm integer is '1', so add the word
5991                 # to the filter list.
5992
5993                 # First, check the variables recieved are UTF8
5994                 # copliant.
5995
5996                 kiriwrite_variablecheck($filter_new_find, "utf8", 0, 0);
5997                 kiriwrite_variablecheck($filter_new_replace, "utf8", 0, 0);
5998                 kiriwrite_variablecheck($filter_new_priority, "utf8", 0, 0);
5999
6000                 # Convert the UTF8 values so that the length can
6001                 # checked properly.
6002
6003                 $filter_new_find        = kiriwrite_utf8convert($filter_new_find);
6004                 $filter_new_replace     = kiriwrite_utf8convert($filter_new_replace);
6005                 $filter_new_priority    = kiriwrite_utf8convert($filter_new_priority);
6006
6007                 # Check if the find filter is blank and return an error
6008                 # if it is.
6009
6010                 if (!$filter_new_find){
6011
6012                         # The find filter given is blank so return an
6013                         # error.
6014
6015                         kiriwrite_error("blankfindfilter");
6016
6017                 }
6018
6019                 if (!$filter_new_priority){
6020
6021                         # The filter priority is blank so set it
6022                         # to 1.
6023
6024                         $filter_new_priority = 1;
6025
6026                 }
6027
6028                 # Check the length and contents of the values given
6029                 # to make sure they are valid.
6030
6031                 my $filterfind_maxlength_check          = kiriwrite_variablecheck($filter_new_find, "maxlength", 1024, 1);
6032                 my $filterreplace_maxlength_check       = kiriwrite_variablecheck($filter_new_replace, "maxlength", 1024, 1);
6033                 my $filterpriority_maxlength_check      = kiriwrite_variablecheck($filter_new_priority, "maxlength", 5, 1);
6034                 my $filterpriority_numbers_check        = kiriwrite_variablecheck($filter_new_priority, "numbers", 0, 1);
6035
6036                 # Check if the result of the tests to see if they
6037                 # are valid.
6038
6039                 if ($filterfind_maxlength_check eq 1){
6040
6041                         # The find filter is too long, so return
6042                         # an error.
6043
6044                         kiriwrite_error("findfiltertoolong");
6045
6046                 }
6047
6048                 if ($filterreplace_maxlength_check eq 1){
6049
6050                         # The replace filter is too long, so
6051                         # return an error.
6052
6053                         kiriwrite_error("replacefiltertoolong");
6054
6055                 }
6056
6057                 if ($filterpriority_maxlength_check eq 1){
6058
6059                         # The length of the filter priority
6060                         # given is too long, so return an
6061                         # error.
6062
6063                         kiriwrite_error("filterprioritytoolong");
6064
6065                 }
6066
6067                 if ($filterpriority_numbers_check eq 1){
6068
6069                         # The priority of the filter given
6070                         # contains characters other than
6071                         # numbers.
6072
6073                         kiriwrite_error("filterpriorityinvalidchars");
6074
6075                 }
6076
6077                 # Check if the filter priority is less than 1
6078                 # and more than 10000 and return an error
6079                 # if it is.
6080
6081                 if ($filter_new_priority < 1 || $filter_new_priority > 50000){
6082
6083                         # The filter priority is less than 1 and
6084                         # more than 10000, so return an error.
6085
6086                         kiriwrite_error("filterpriorityinvalid");
6087
6088                 }
6089
6090                 # Define some variables for later on.
6091
6092                 my @database_filters;
6093                 my @database_check;
6094
6095                 my $database_handle;
6096                 my $string_handle;
6097                 my $chk_database_handle;
6098                 my $chk_string_handle;
6099
6100                 my $filters_exist;
6101                 my $filters_permissions;
6102                 my $filters_count       = 0;
6103                 my $blankid_found       = 0;
6104                 my $current_id          = 0;
6105                 my $next_id             = 0;
6106                 my $filter_exists       = 0;
6107
6108                 my $first_filter        = 0;
6109
6110                 my $new_id;
6111
6112                 # Check if the filters database exists, has valid
6113                 # permission settings and if it doesn't create
6114                 # the database first.
6115
6116                 $filters_exist = kiriwrite_fileexists("filters.db");
6117
6118                 if ($filters_exist eq 0){
6119
6120                         # The filters database does exist, so don't
6121                         # bother trying to create another one.
6122
6123                         $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 1, 1);
6124
6125                         if ($filters_permissions eq 1){
6126
6127                                 # The filters database has invalid permissions so
6128                                 # return an error.
6129
6130                                 kiriwrite_error("filtersdbpermissions");
6131
6132                         }
6133
6134                         # Load the SQLite database.
6135
6136                         $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
6137
6138                 } else {
6139
6140                         # The filters database does not exist, so create
6141                         # the filters database.
6142
6143                         # Check if the filters database can really be
6144                         # created.
6145
6146                         my $directory_permissions = kiriwrite_filepermissions(".", 1, 1, 0);
6147
6148                         if ($directory_permissions eq 1){
6149
6150                                 # The filters database cannot be created because of invalid directory
6151                                 # permissions so return an error.
6152
6153                                 kiriwrite_error("filtersdatabasefilenotcreated");
6154                         }
6155
6156                         # Create the filters database.
6157
6158                         $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
6159                         $string_handle          = $database_handle->prepare('create table kiriwrite_filters(
6160                                         id int(7) primary key,
6161                                         priority int(5),
6162                                         findsetting varchar(1024),
6163                                         replacesetting varchar(1024),
6164                                         notes text
6165                                 );
6166                         ');
6167                         $string_handle->execute();
6168
6169                 }
6170
6171                 $chk_database_handle    = DBI->connect("dbi:SQLite:dbname=filters.db");
6172
6173                 # Find the lowest identification number available.
6174
6175                 $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY id ASC') or kiriwrite_error("filtersdbinvalidformat");;
6176                 $string_handle->execute();
6177
6178                 # Process each filter to find a blank identification
6179                 # number.
6180
6181                 while(@database_filters = $string_handle->fetchrow_array()){
6182
6183                         # Check the next filter identification number to see
6184                         # if it exists and use that identification number if
6185                         # it doesn't exist.
6186
6187                         $current_id             = $database_filters[0];
6188                         $next_id                = $current_id + 1;
6189                         $chk_string_handle      = $chk_database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $next_id . '\' LIMIT 1');
6190                         $chk_string_handle->execute();
6191
6192                         while(@database_check = $chk_string_handle->fetchrow_array()){
6193
6194                                 $filter_exists = 1;
6195
6196
6197                         }
6198
6199                         if ($filter_exists eq 0 && $blankid_found eq 0){
6200
6201                                 $new_id         = $next_id;
6202                                 $blankid_found  = 1;
6203
6204                         }
6205
6206                         # Check if this is the first filter and the current
6207                         # identification number is more than 1 and if it
6208                         # is then set the new identification number to 1.
6209
6210                         if ($first_filter eq 0 && $current_id > 1 && $blankid_found eq 0){
6211
6212                                 # The first filter has an identification
6213                                 # number more than 1, so set the new
6214                                 # identification number to 1.
6215
6216                                 $new_id         = 1;
6217                                 $blankid_found  = 1;
6218                                 $first_filter   = 1;
6219
6220
6221                         }
6222
6223                         # Set the next identification number as the
6224                         # current identification number add one and
6225                         # increment the filters count.
6226
6227                         $first_filter = 1;
6228                         $filters_count++;
6229                         $filter_exists = 0;
6230
6231                 }
6232
6233                 # Check if there are any filters in the database
6234                 # and if not set the identification number to 1.
6235
6236                 if ($filters_count eq 0){
6237
6238                         # No filters were really in the filters
6239                         # database.
6240
6241                         $new_id = 1;
6242
6243                 }
6244
6245                 # Convert the values so that they can be processed
6246                 # properly.
6247
6248                 my $filter_new_id_sql           = kiriwrite_convert($new_id, "kiriwrite");
6249                 my $filter_new_priority_sql     = kiriwrite_convert($filter_new_priority, "kiriwrite");
6250                 my $filter_new_find_sql         = kiriwrite_convert($filter_new_find, "kiriwrite");
6251                 my $filter_new_replace_sql      = kiriwrite_convert($filter_new_replace, "kiriwrite");
6252                 my $filter_new_notes_sql        = kiriwrite_convert($filter_new_notes, "kiriwrite");
6253
6254                 # Add the new filter to the filters database.
6255
6256                 $string_handle  = $database_handle->prepare('INSERT INTO kiriwrite_filters VALUES(
6257                         \'' . $filter_new_id_sql . '\',
6258                         \'' . $filter_new_priority_sql . '\',
6259                         \'' . $filter_new_find_sql . '\',
6260                         \'' . $filter_new_replace_sql . '\',
6261                         \'' . $filter_new_notes_sql . '\'
6262                 )');
6263                 $string_handle->execute();
6264
6265                 # Write out a message saying that the filter was added to the
6266                 # filters database.
6267
6268                 $pagedata = $pagedata . "<h2>Filter Added</h2>";
6269                 $pagedata = $pagedata . "The filter was added sucessfully to the filters list.<br><br>";
6270                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the filters list.</a>";
6271
6272                 return $pagedata;
6273
6274         } elsif ($confirm ne 0) {
6275
6276                 # The confirm integer is another value (which
6277                 # it shouldn't be) so return an error.
6278
6279                 kiriwrite_error("invalidvalue");
6280
6281         }
6282
6283         # The confirm integer was blank so print out a form
6284         # for adding a new filter.
6285
6286         $pagedata = "<h2>Add Filter</h2>";
6287         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
6288         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
6289         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"add\">";
6290         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
6291         $pagedata = $pagedata . "<table cellspacing=0 cellpadding=5>";
6292         $pagedata = $pagedata . "<Tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
6293         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Find...</td><td class=\"tablecell2\"><input type=\"input\" name=\"findword\" size=\"64\" maxlength=\"1024\"></td></tr>";
6294         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Replace with...</td><td class=\"tablecell2\"><input type=\"input\" name=\"replaceword\" size=\"64\" maxlength=\"1024\"></td></tr>";
6295         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Priority</td><td class=\"tablecell2\"><input type=\"input\" name=\"priority\" size=\"5\" maxlength=\"5\"><br><ul><li>If no filter priority is specified, the filter priority will be set to 1.</li></ul></td></tr>";
6296         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Notes</td><td class=\"tablecell2\"><textarea name=\"notes\" cols=\"50\" rows=\"10\"></textarea></td></tr>";
6297         $pagedata = $pagedata . "</table>";
6298         $pagedata = $pagedata . "<br>";
6299         $pagedata = $pagedata . "<input type=\"submit\" value=\"Add Filter\"> | <input type=\"reset\" value=\"Clear values\">";
6300         $pagedata = $pagedata . "</form>";
6301
6302         return $pagedata;
6303
6304 }
6305
6306 sub kiriwrite_filter_edit{
6307 #################################################################################
6308 # kiriwrite_filter_edit: Edits a filter from the filter list.                   #
6309 #                                                                               #
6310 # Usage:                                                                        #
6311 #                                                                               #
6312 # kiriwrite_filter_edit(filternumber, newfilterfind, newfilterreplace,          #
6313 #                       newfilterpriority, newfilternotes, confirm);            #
6314 #                                                                               #
6315 # filterid              Specifies the filter number (line number) in the        #
6316 #                       filters database.                                       #
6317 # newfilterfind         Specifies the new word to find.                         #
6318 # newfilterreplace      Specifies the new word to replace.                      #
6319 # newfilterpriority     Specifies the new filter priority.                      #
6320 # newfilternotes        Specifies the new filter notes.                         #
6321 # confirm               Confirms the action to edit a filter.                   #
6322 #################################################################################
6323
6324         # Get the values that have been passed to the subroutine.
6325
6326         my ($filter_id, $filter_new_find, $filter_new_replace, $filter_new_priority, $filter_new_notes, $confirm) = @_;
6327
6328         # Load the needed Perl modules.
6329
6330         use DBI;
6331
6332         # Check the confirm value to make sure it is no more than
6333         # one character long.
6334
6335         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
6336
6337         # Define the page data value for later.
6338
6339         my $pagedata = "";
6340
6341         # Check if the confirm value is blank and if it is
6342         # srt the confirm value to 0.
6343
6344         if (!$confirm){
6345
6346                 # The confirm value does not have any value
6347                 # set so set it to 0.
6348
6349                 $confirm = 0;
6350
6351         }
6352
6353         # Check if the filter identification number is blank,
6354         # contains characters other than numbers and is more
6355         # than seven characters long.
6356
6357         if (!$filter_id){
6358
6359                 # The filter identification number is blank,
6360                 # so return an error.
6361
6362                 kiriwrite_error("filteridblank");
6363
6364         }
6365
6366         my $filter_id_numbers_check     = kiriwrite_variablecheck($filter_id, "numbers", 0, 1);
6367
6368         if ($filter_id_numbers_check eq 1){
6369
6370                 # The filter identification number contains
6371                 # characters other than numbers, so return
6372                 # an error.
6373
6374                 kiriwrite_error("filteridinvalid");
6375
6376         }
6377
6378         my $filter_id_maxlength_check   = kiriwrite_variablecheck($filter_id, "maxlength", 7, 1);
6379
6380         if ($filter_id_maxlength_check eq 1){
6381
6382                 # The filter identification number given
6383                 # is more than seven characters long, so
6384                 # return an error.
6385
6386                 kiriwrite_error("filteridtoolong");
6387
6388         }
6389
6390         # Check if the filters database exists and the
6391         # permissions for it are valid.
6392
6393         my $filters_exists      = kiriwrite_fileexists("filters.db");
6394
6395         if ($filters_exists eq 1){
6396
6397                 # The filters database does not exist, so
6398                 # return an error.
6399
6400                 kiriwrite_error("filtersdbmissing");
6401
6402         }
6403
6404         my $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 0);
6405
6406         if ($filters_permissions eq 1){
6407
6408                 # The filters database has invalid permissions
6409                 # set, so return an error.
6410
6411                 kiriwrite_error("filtersdbpermissions");
6412
6413         }
6414
6415         # Define some variables for later.
6416
6417         my $database_handle;
6418         my $string_handle;
6419         my $filter_id_sql       = kiriwrite_convert($filter_id, "kiriwrite");
6420         my $filter_id_out       = kiriwrite_convert($filter_id, "normal_display");
6421         my $filter_priority;
6422         my $filter_priority_sql;
6423         my $filter_priority_out;
6424         my $filter_find;
6425         my $filter_find_sql;
6426         my $filter_find_out;
6427         my $filter_replace;
6428         my $filter_replace_sql;
6429         my $filter_replace_out;
6430         my $filter_notes;
6431         my $filter_notes_sql;
6432         my $filter_notes_out;
6433
6434         # Check if the action to edit a filter has been
6435         # confirmed.
6436
6437         # Load the SQLite database.
6438
6439         $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
6440
6441         if ($confirm eq 1){
6442
6443                 # The action to edit a filter has been confirmed so
6444                 # edit the selected filter.
6445
6446                 # Check if changes to the database can be written to.
6447
6448                 $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 1);
6449
6450                 if ($filters_permissions eq 1){
6451
6452                         # The filters database has invalid permissions
6453                         # set, so return an error.
6454
6455                         kiriwrite_error("filtersdbpermissions");
6456
6457                 }
6458
6459                 # Define some variables for later.
6460
6461                 my @database_filter;
6462                 my $filter_exists = 0;
6463
6464                 # Check if the filter exists.
6465
6466                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filter_id_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
6467                 $string_handle->execute();
6468
6469                 while (@database_filter = $string_handle->fetchrow_array()){
6470
6471                         # The filter exists.
6472
6473                         $filter_exists = 1;
6474
6475                 }
6476
6477                 # Check if the filter really doesn't exist.
6478
6479                 if ($filter_exists eq 0){
6480
6481                         # The filter really does not exist so
6482                         # return an error.
6483
6484                         kiriwrite_error("filterdoesnotexist");
6485
6486                 }
6487
6488                 # First, check the variables recieved are UTF8
6489                 # copliant.
6490
6491                 kiriwrite_variablecheck($filter_new_find, "utf8", 0, 0);
6492                 kiriwrite_variablecheck($filter_new_replace, "utf8", 0, 0);
6493                 kiriwrite_variablecheck($filter_new_priority, "utf8", 0, 0);
6494                 kiriwrite_variablecheck($filter_new_notes, "utf8", 0, 0);
6495
6496                 # Convert the UTF8 values so that the length can
6497                 # checked properly.
6498
6499                 $filter_find            = kiriwrite_utf8convert($filter_new_find);
6500                 $filter_replace         = kiriwrite_utf8convert($filter_new_replace);
6501                 $filter_priority        = kiriwrite_utf8convert($filter_new_priority);
6502                 $filter_notes           = kiriwrite_utf8convert($filter_new_notes);
6503
6504                 # Check if the find filter is blank and return an error
6505                 # if it is.
6506
6507                 if (!$filter_new_find){
6508
6509                         # The find filter given is blank so return an
6510                         # error.
6511
6512                         kiriwrite_error("blankfindfilter");
6513
6514                 }
6515
6516                 if (!$filter_new_priority){
6517
6518                         # The filter priority is blank so set it
6519                         # to 1.
6520
6521                         $filter_new_priority = 1;
6522
6523                 }
6524
6525                 # Check the length and contents of the values given
6526                 # to make sure they are valid.
6527
6528                 my $filterfind_maxlength_check          = kiriwrite_variablecheck($filter_new_find, "maxlength", 1024, 1);
6529                 my $filterreplace_maxlength_check       = kiriwrite_variablecheck($filter_new_replace, "maxlength", 1024, 1);
6530                 my $filterpriority_maxlength_check      = kiriwrite_variablecheck($filter_new_priority, "maxlength", 5, 1);
6531                 my $filterpriority_numbers_check        = kiriwrite_variablecheck($filter_new_priority, "numbers", 0, 1);
6532
6533                 # Check if the result of the tests to see if they
6534                 # are valid.
6535
6536                 if ($filterfind_maxlength_check eq 1){
6537
6538                         # The find filter is too long, so return
6539                         # an error.
6540
6541                         kiriwrite_error("findfiltertoolong");
6542
6543                 }
6544
6545                 if ($filterreplace_maxlength_check eq 1){
6546
6547                         # The replace filter is too long, so
6548                         # return an error.
6549
6550                         kiriwrite_error("replacefiltertoolong");
6551
6552                 }
6553
6554                 if ($filterpriority_maxlength_check eq 1){
6555
6556                         # The length of the filter priority
6557                         # given is too long, so return an
6558                         # error.
6559
6560                         kiriwrite_error("filterprioritytoolong");
6561
6562                 }
6563
6564                 if ($filterpriority_numbers_check eq 1){
6565
6566                         # The priority of the filter given
6567                         # contains characters other than
6568                         # numbers.
6569
6570                         kiriwrite_error("filterpriorityinvalidchars");
6571
6572                 }
6573
6574                 # Check if the filter priority is less than 1
6575                 # and more than 10000 and return an error
6576                 # if it is.
6577
6578                 if ($filter_new_priority < 1 || $filter_new_priority > 50000){
6579
6580                         # The filter priority is less than 1 and
6581                         # more than 10000, so return an error.
6582
6583                         kiriwrite_error("filterpriorityinvalid");
6584
6585                 }
6586
6587                 # Convert the new information about the filter given
6588                 # so that it can be added to the SQL query properly.
6589
6590                 $filter_find_sql        = kiriwrite_convert($filter_find, "kiriwrite");
6591                 $filter_replace_sql     = kiriwrite_convert($filter_replace, "kiriwrite");
6592                 $filter_priority_sql    = kiriwrite_convert($filter_priority, "kiriwrite");
6593                 $filter_notes_sql       = kiriwrite_convert($filter_notes, "kiriwrite");
6594
6595                 # Edit the filter using the information provided.
6596
6597                 $string_handle = $database_handle->prepare('UPDATE kiriwrite_filters SET priority = \'' . $filter_priority_sql . '\', findsetting = \'' . $filter_find_sql . '\', replacesetting = \'' . $filter_replace_sql . '\', notes = \'' . $filter_notes_sql . '\' WHERE id = \'' . $filter_id_sql . '\'');
6598                 $string_handle->execute();
6599
6600                 # Write a message saying that the filter was edited.
6601
6602                 $pagedata = $pagedata . "<h2>Filter edited</h2>";
6603                 $pagedata = $pagedata . "The selected filter was edited.<br><br>";
6604                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the list of filters.</a>";
6605
6606                 return $pagedata;
6607
6608         } elsif ($confirm eq 0){
6609
6610                 # The action to edit a filter has not been confirmed
6611                 # so write a form for editing the filter with.
6612
6613                 # Define some variables for later.
6614
6615                 my @database_filter;
6616                 my $filter_exists = 0;
6617
6618                 # Check if the filter exists.
6619
6620                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filter_id_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
6621                 $string_handle->execute();
6622
6623                 while (@database_filter = $string_handle->fetchrow_array()){
6624
6625                         # The filter exists.
6626
6627                         $filter_exists = 1;
6628
6629                 }
6630
6631                 # Check if the filter really doesn't exist.
6632
6633                 if ($filter_exists eq 0){
6634
6635                         # The filter really does not exist so
6636                         # return an error.
6637
6638                         kiriwrite_error("filterdoesnotexist");
6639
6640                 }
6641
6642                 # Get the filter information.
6643
6644                 $string_handle->execute();
6645
6646                 @database_filter = $string_handle->fetchrow_array();
6647
6648                 # Get the required information.
6649
6650                 $filter_priority        = $database_filter[1];
6651                 $filter_find            = $database_filter[2];
6652                 $filter_replace         = $database_filter[3];
6653                 $filter_notes           = $database_filter[4];
6654
6655                 $filter_priority_out    = kiriwrite_convert($filter_priority, "normal_display");
6656                 $filter_find_out        = kiriwrite_convert($filter_find, "normal_display");
6657                 $filter_replace_out     = kiriwrite_convert($filter_replace, "normal_display");
6658                 $filter_notes_out       = kiriwrite_convert($filter_notes, "normal_display");
6659
6660                 # Write out the form.
6661
6662                 $pagedata = $pagedata . "<h2>Edit Filter</h2>";
6663                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
6664                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
6665                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
6666                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"filter\" value=\"" . $filter_id_out . "\">";
6667                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
6668                 $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
6669                 $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
6670                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Find...</td><td class=\"tablecell2\"><input type=\"text\" name=\"filterfind\" size=\"64\" maxlength=\"1024\" value=\"" . $filter_find_out . "\"></td><tr>";
6671                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Replace With...</td><td class=\"tablecell2\"><input type=\"text\" name=\"filterreplace\" size=\"64\" maxlength=\"1024\" value=\"" . $filter_replace_out . "\"></td><tr>";
6672                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Priority</td><td class=\"tablecell2\"><input type=\"text\" name=\"priority\" size=\"5\" maxlength=\"5\" value=\"" . $filter_priority_out . "\"><ul><li>If no filter priority is specified, the filter priority will be set to 1.</li></ul></td><tr>";
6673                 $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Filter Notes</td><td class=\"tablecell2\"><textarea name=\"notes\" rows=\"10\" cols=\"50\">" . $filter_notes_out . "</textarea></td><tr>";
6674                 $pagedata = $pagedata . "</table><br>";
6675                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Edit filter\"> | <input type=\"reset\" value=\"Restore filter settings\"> | <a href=\"kiriwrite.cgi?mode=filter\">Return to the filter database.</a>";
6676                 $pagedata = $pagedata . "</form>";
6677
6678                 return $pagedata;
6679
6680         } else {
6681
6682                 # A confirm value other than 0 or 1 has been
6683                 # specified, so return an error.
6684
6685                 kiriwrite_error("invalidvalue");
6686
6687         }
6688
6689 }
6690
6691 sub kiriwrite_filter_delete{
6692 #################################################################################
6693 # kiriwrite_filter_delete: Deletes a filter from the filter list.               #
6694 #                                                                               #
6695 # Usage:                                                                        #
6696 #                                                                               #
6697 # kiriwrite_filter_delete(number, confirm);                                     #
6698 #                                                                               #
6699 # number        Specifies the filter line number to delete.                     #
6700 # confirm       Confirms the deletion of the selected filter.                   #
6701 #################################################################################
6702
6703         # Get the values that were passed to this subroutine.
6704
6705         my ($filter_id, $confirm) = @_;
6706
6707         # Load the needed Perl modules.
6708
6709         use DBI;
6710
6711         # Check the confirm value to make sure it is no more than
6712         # one character long.
6713
6714         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
6715
6716         # Define the page data value for later.
6717
6718         my $pagedata = "";
6719
6720         # Check if the confirm value is blank and if it is
6721         # srt the confirm value to 0.
6722
6723         if (!$confirm){
6724
6725                 # The confirm value does not have any value
6726                 # set so set it to 0.
6727
6728                 $confirm = 0;
6729
6730         }
6731
6732         # Check if the filter identification number is blank,
6733         # contains characters other than numbers and is more
6734         # than seven characters long.
6735
6736         if (!$filter_id){
6737
6738                 # The filter identification number is blank,
6739                 # so return an error.
6740
6741                 kiriwrite_error("filteridblank");
6742
6743         }
6744
6745         my $filter_id_numbers_check     = kiriwrite_variablecheck($filter_id, "numbers", 0, 1);
6746
6747         if ($filter_id_numbers_check eq 1){
6748
6749                 # The filter identification number contains
6750                 # characters other than numbers, so return
6751                 # an error.
6752
6753                 kiriwrite_error("filteridinvalid");
6754
6755         }
6756
6757         my $filter_id_maxlength_check   = kiriwrite_variablecheck($filter_id, "maxlength", 7, 1);
6758
6759         if ($filter_id_maxlength_check eq 1){
6760
6761                 # The filter identification number given
6762                 # is more than seven characters long, so
6763                 # return an error.
6764
6765                 kiriwrite_error("filteridtoolong");
6766
6767         }
6768
6769         # Check if the filters database exists and the
6770         # permissions for it are valid.
6771
6772         my $filters_exists      = kiriwrite_fileexists("filters.db");
6773
6774         if ($filters_exists eq 1){
6775
6776                 # The filters database does not exist, so
6777                 # return an error.
6778
6779                 kiriwrite_error("filtersdbmissing");
6780
6781         }
6782
6783         my $filters_permissions = kiriwrite_filepermissions("filters.db", 1, 0);
6784
6785         if ($filters_permissions eq 1){
6786
6787                 # The filters database has invalid permissions
6788                 # set, so return an error.
6789
6790                 kiriwrite_error("filtersdbpermissions");
6791
6792         }
6793
6794         # Define some values for later.
6795
6796         my @database_filter;
6797         my $filterid_sql        = kiriwrite_convert($filter_id, "kiriwrite");
6798         my $filterid_out        = kiriwrite_convert($filter_id, "normal_display");
6799         my $database_handle;
6800         my $string_handle;
6801         my $filter_exists = 0;
6802
6803         # Load the SQLite database.
6804
6805         $database_handle        = DBI->connect("dbi:SQLite:dbname=filters.db");
6806
6807         # Check if the confirm integer has a value of '1'.
6808
6809         if ($confirm eq 1){
6810
6811                 # The action to delete a filter has been confirmed.
6812
6813                 # Check the permissions of the filters database is
6814                 # valid (for writing).
6815
6816                 $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 1);
6817
6818                 if ($filters_permissions eq 1){
6819
6820                         # The filters database has invalid permissions
6821                         # set, so return an error.
6822
6823                         kiriwrite_error("filtersdbpermissions");
6824
6825                 }
6826
6827                 # Check if the filter exists.
6828
6829                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filterid_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
6830                 $string_handle->execute();
6831
6832                 while (@database_filter = $string_handle->fetchrow_array()){
6833
6834                         # The filter exists.
6835
6836                         $filter_exists = 1;
6837
6838                 }
6839
6840                 # Check if the filter really doesn't exist.
6841
6842                 if ($filter_exists eq 0){
6843
6844                         # The filter really does not exist so
6845                         # return an error.
6846
6847                         kiriwrite_error("filterdoesnotexist");
6848
6849                 }
6850
6851                 # Delete the filter from the filters database.
6852
6853                 $string_handle  = $database_handle->prepare('DELETE FROM kiriwrite_filters where id = \'' . $filterid_sql . '\'') or kiriwrite_error("filtersdbinvalidformat");
6854                 $string_handle->execute();
6855
6856                 # Write a message saying that the filter was deleted
6857                 # from the filters database.
6858
6859                 $pagedata = $pagedata . "<h2>Delete Filter</h2>";
6860                 $pagedata = $pagedata . "The selected filter was deleted from the filters database.<br><br>";
6861                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=filter\">Return to the filters database.</a>";
6862
6863         } elsif ($confirm eq 0) {
6864
6865                 # The action to delete a filter has not been confirmed so write
6866                 # a form asking for the user to confirm the deletion of the
6867                 # filter.
6868
6869                 # Check if the filter exists.
6870
6871                 $string_handle  = $database_handle->prepare('SELECT * FROM kiriwrite_filters WHERE id = \'' . $filterid_sql . '\' LIMIT 1') or kiriwrite_error("filtersdbinvalidformat");
6872                 $string_handle->execute();
6873
6874                 while (@database_filter = $string_handle->fetchrow_array()){
6875
6876                         # The filter exists.
6877
6878                         $filter_exists = 1;
6879
6880                 }
6881
6882                 # Check if the filter really doesn't exist.
6883
6884                 if ($filter_exists eq 0){
6885
6886                         # The filter really does not exist so
6887                         # return an error.
6888
6889                         kiriwrite_error("filterdoesnotexist");
6890
6891                 }
6892
6893                 # The confirm integer is '0', so continue write out
6894                 # a form asking the user to confirm the deletion
6895                 # pf the filter.
6896
6897                 $pagedata = $pagedata . "<h2>Confirm deletion</h2>";
6898                 $pagedata = $pagedata . "Are you sure you want to delete the selected filter?<br><br>";
6899                 $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
6900                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"filter\">";
6901                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"delete\">";
6902                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"filter\" value=\"" . $filterid_out . "\">";
6903                 $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
6904                 $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, delete the selected filter\"> | <a href=\"kiriwrite.cgi?mode=filter\">No, return to the filters list.</a>";
6905                 $pagedata = $pagedata . "</form>";
6906
6907         } else {
6908
6909                 kiriwrite_error("invalidvalue");
6910
6911         }
6912
6913         return $pagedata;
6914
6915 }
6916
6917 sub kiriwrite_compile_makepages{
6918 #################################################################################
6919 # kiriwrite_compile_makepages: Compile the selected pages and place them in the #
6920 # specified output directory.                                                   #
6921 #                                                                               #
6922 # Usage:                                                                        #
6923 #                                                                               #
6924 # kiriwrite_compile_makepages(type, selectedlist, confirm);                     #
6925 #                                                                               #
6926 # type          Specifies if single or multiple databases are to be compiled.   #
6927 # confirm       Specifies if the action to compile the databases should really  #
6928 #               be done.                                                        #
6929 # selectedlist  Specifies the databases to compile from as an array.            #
6930 #################################################################################
6931
6932         # Get the values that have been passed to the subroutine.
6933
6934         my ($type, $confirm, @selectedlist) = @_;
6935
6936         # Check if the confirm value is more than one
6937         # character long.
6938
6939         kiriwrite_variablecheck($confirm, "maxlength", 1, 0);
6940
6941         # Check if the confirm value is blank and if it
6942         # is then set the confirm value to 0.
6943
6944         if (!$confirm){
6945
6946                 # The confirm value is blank, so set the
6947                 # confirm value to 0.
6948
6949                 $confirm = 0;
6950
6951         }
6952
6953         # Check if there are any databases selected
6954         # and return an error if there isn't.
6955
6956         if (!@selectedlist){
6957
6958                 # There are no databases in the array
6959                 # so return an error.
6960
6961                 kiriwrite_error("nodatabaseselected");
6962
6963         }
6964
6965         # Check if the type given is no more than
6966         # 7 characters long.
6967
6968         my $type_maxlength_check = kiriwrite_variablecheck($type, "maxlength", 8, 1);
6969
6970         if ($type_maxlength_check eq 1){
6971
6972                 # The type length given is too long so
6973                 # return an error.
6974
6975                 kiriwrite_error("variabletoolong");
6976
6977         }
6978
6979         # Define the following values for later.
6980
6981         my $pagedata = "";
6982
6983         # Check if the action to compile the databases
6984         # has been confirmed.
6985
6986         if ($confirm eq 1){
6987
6988                 # The action to compile the datavases has
6989                 # been confirmed.
6990
6991                 # Define some variables for later.
6992
6993                 my %templatefiles;
6994                 my @databaseinfo;
6995                 my @databasepages;
6996                 my @filterslist;
6997                 my @findfilter;
6998                 my @replacefilter;
6999                 my @templateslist;
7000                 my @pagedirectories;
7001                 my $messages                    = "";
7002                 my $warning_count               = 0;
7003                 my $error_count                 = 0;
7004                 my $pages_count                 = 0;
7005                 my $filters_count               = 0;
7006                 my $filters_find_blank_warning  = 0;
7007                 my $database_handle;
7008                 my $string_handle;
7009                 my $filter_find;
7010                 my $filter_replace;
7011                 my $database;
7012                 my $database_out;
7013                 my $database_name;
7014                 my $database_name_out;
7015                 my $page_filename;
7016                 my $page_filename_out;
7017                 my $page_filename_check;
7018                 my $page_filename_char          = "";
7019                 my $page_filename_directory;
7020                 my $page_filename_length        = 0;
7021                 my $page_filename_seek          = 0;
7022                 my $page_filename_dircount      = 0;
7023                 my $page_directory_name;
7024                 my $page_directory_path;
7025                 my $page_name;
7026                 my $page_name_out;
7027                 my $page_description;
7028                 my $page_section;
7029                 my $page_template;
7030                 my $page_template_out;
7031                 my $page_content;
7032                 my $page_settings;
7033                 my $page_lastmodified;
7034                 my $page_title;
7035                 my $page_final;
7036                 my $page_autosection;
7037                 my $page_autotitle;
7038                 my $database_filename_check     = 0;
7039                 my $database_maxlength_check    = 0;
7040                 my $output_exists               = 0;
7041                 my $output_permissions          = 0;
7042                 my $filters_exists              = 0;
7043                 my $filters_permissions         = 0;
7044                 my $filters_skip                = 0;
7045                 my $templates_exists            = 0;
7046                 my $templates_permissions       = 0;
7047                 my $templates_skip              = 0;
7048                 my $database_exists             = 0;
7049                 my $database_permissions        = 0;
7050                 my $information_prefix          = "[Information] ";
7051                 my $error_prefix                = "[Error] ";
7052                 my $warning_prefix              = "[Warning] ";
7053
7054                 # Check if the output directory exists and has
7055                 # valid permissions set.
7056
7057                 $output_exists          = kiriwrite_fileexists($kiriwrite_config{'directory_data_output'});
7058
7059                 if ($output_exists ne 0){
7060
7061                         # The output directory does not exist so
7062                         # return an error.
7063
7064                         kiriwrite_error("outputdirectorymissing");
7065
7066                 }
7067
7068                 $output_permissions     = kiriwrite_filepermissions($kiriwrite_config{'directory_data_output'}, 1, 1);
7069
7070                 if ($output_permissions ne 0){
7071
7072                         # The output directory has invalid
7073                         # permissions set so return an error.
7074
7075                         kiriwrite_error("outputdirectoryinvalidpermissions");
7076
7077                 }
7078
7079                 # Check if the filters database exists and has valid
7080                 # permissions set.
7081
7082                 $filters_exists         = kiriwrite_fileexists("filters.db");
7083
7084                 if ($filters_exists ne 0){
7085
7086                         # The filters database does not exist
7087                         # so write a warning.
7088
7089                         $messages = $messages . $warning_prefix . "The filters database does not exist. No filters will be used." . "<br>";
7090                         $filters_skip = 1;
7091                         $warning_count++;
7092
7093                 }
7094
7095                 $filters_permissions    = kiriwrite_filepermissions("filters.db", 1, 0);
7096
7097                 if ($filters_permissions ne 0 && $filters_exists eq 0){
7098
7099                         # The filters database has invalid
7100                         # permissions set so write a warning.
7101
7102                         $messages = $messages . $warning_prefix . "The filters database has invalid permissions set. No filters will be used." . "<br>";
7103                         $filters_skip = 1;
7104                         $warning_count++;
7105
7106                 }
7107
7108                 # Load the filters database (if the filters skip
7109                 # value isn't set to 1).
7110
7111                 if ($filters_skip eq 0){
7112
7113                         # Load the filters database.
7114
7115                         $database_handle = DBI->connect("dbi:SQLite:dbname=filters.db");
7116                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_filters ORDER BY priority ASC') or $messages = $messages . $error_prefix . "The filters database is in an invalid format. No filters will be used." . "<br>", $error_count++, $filters_skip = 1;
7117
7118                         # Check if the filters skip value is set to 0
7119                         # before executing the query.
7120
7121                         if ($filters_skip eq 0){
7122
7123                                 # Get the filters.
7124
7125                                 $string_handle->execute();
7126                                 while (@filterslist = $string_handle->fetchrow_array()){
7127
7128                                         # Check if the find filter is blank and
7129                                         # if it is then write a warning message.
7130
7131                                         if (!$filterslist[2]){
7132
7133                                                 if ($filters_find_blank_warning ne 1){
7134
7135                                                         $messages = $messages . $warning_prefix . "One (or more) of the find filters from the filters database is blank." . "<br>";
7136                                                         $filters_find_blank_warning = 1;
7137                                                 }
7138                                                 next;
7139
7140                                         } else {
7141
7142                                                 # Add each find and replace filter.
7143
7144                                                 $findfilter[$filters_count]     = $filterslist[2];
7145                                                 $replacefilter[$filters_count]  = $filterslist[3];
7146
7147                                         }
7148
7149                                         $filters_count++;
7150
7151                                 }
7152                                 $messages = $messages . $information_prefix . "The filters database has been loaded." . "<br>";
7153
7154                         }
7155
7156                 }
7157
7158                 # Check if the templates database exists and has
7159                 # valid permissions set.
7160
7161                 $templates_exists       = kiriwrite_fileexists("templates.db");
7162
7163                 if ($templates_exists ne 0){
7164
7165                         # The template database does not exist
7166                         # so write a warning.
7167
7168                         $messages = $messages . $warning_prefix . "The templates database does not exist. Pages will be compiled without templates being used." . "<br>";
7169                         $templates_skip = 1;
7170                         $warning_count++;
7171
7172                 }
7173
7174                 $templates_permissions  = kiriwrite_filepermissions("templates.db", 1, 0);
7175
7176                 if ($templates_permissions ne 0 && $templates_exists eq 0){
7177
7178                         # The template database has invalid
7179                         # permissions set so write a warning.
7180
7181                         $messages = $messages . $warning_prefix . "The templates database has invalid permissions set. Pages will be compiled without templates being used." . "<br>";
7182                         $templates_skip = 1;
7183                         $warning_count++;
7184
7185                 }
7186
7187                 # Load the templates database (if the template
7188                 # skip value isn't set to 1).
7189
7190                 if ($templates_skip eq 0){
7191
7192                         # Load the templates database.
7193
7194                         $database_handle = DBI->connect('dbi:SQLite:dbname=templates.db');
7195                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_templates') or $messages = $messages . $error_prefix . "The templates database is in an invalid format. Pages will be compiled without templates being used." . "<br>", $error_count++, $templates_skip = 1;
7196
7197                         # Check if the templates skip value is set to
7198                         # 0 before executing the query.
7199
7200                         if ($templates_skip eq 0){
7201
7202                                 # Get the templates and place them into the
7203                                 # template files hash.
7204
7205                                 $string_handle->execute();
7206                                 while(@templateslist = $string_handle->fetchrow_array()){
7207
7208                                         # Place each template file into the hash.
7209
7210                                         $templatefiles{$templateslist[0]}{template}     = $templateslist[3];
7211                                         $templatefiles{$templateslist[0]}{valid}        = 1;
7212
7213                                 }
7214                                 $messages = $messages . $information_prefix . "The templates database has been loaded." . "<br>";
7215
7216                         }
7217
7218                 }
7219
7220                 # Process each database.
7221
7222                 foreach $database (@selectedlist){
7223
7224                         # Check if the database filename and length
7225                         # are valid.
7226
7227                         $messages = $messages . "<hr>";
7228
7229                         $database_out   = kiriwrite_convert($database, "normal_display");
7230                         $database_filename_check        = kiriwrite_variablecheck($database, "page_filename", "", 1);
7231                         $database_maxlength_check       = kiriwrite_variablecheck($database, "maxlength", 64, 1);
7232
7233                         if ($database_filename_check ne 0){
7234
7235                                 # The database filename is invalid, so process
7236                                 # the next database.
7237
7238                                 $messages       = $messages . $error_prefix . "The database filename '" . $database_out . ".db' is invalid. Skipping this database..." . "<br>";
7239                                 $error_count++;
7240                                 next;
7241
7242                         }
7243
7244                         if ($database_maxlength_check ne 0){
7245
7246                                 # The database file is too long, so process the
7247                                 # next database.
7248
7249                                 $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is too long. Skipping this database..." . "<br>";
7250                                 $error_count++;
7251                                 next;
7252
7253                         }
7254
7255                         # Check if the database exists and has valid
7256                         # permissions set.
7257
7258                         $database_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
7259
7260                         if ($database_exists ne 0){
7261
7262                                 # The database does not exist so process
7263                                 # the next database.
7264
7265                                 $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' does not exist. Skipping this database..." . "<br>";
7266                                 $error_count++;
7267                                 next;
7268
7269                         }
7270
7271                         $database_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $database . '.db', 1, 0);
7272
7273                         if ($database_permissions ne 0){
7274
7275                                 # The permissions for the database are invalid
7276                                 # so process the next database.
7277
7278                                 $messages       = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' has invalid permissions set. Skipping this database..." . "<br>";
7279                                 $error_count++;
7280                                 next;
7281
7282                         }
7283
7284                         # Load the SQLite database.
7285
7286                         $database_handle = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $database . '.db');
7287
7288                         # Get the database name.
7289
7290                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or $messages = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is in an invalid format. Skipping this database..." . "<br>", next;
7291                         $string_handle->execute();
7292                         @databaseinfo = $string_handle->fetchrow_array();
7293                         $database_name = $databaseinfo[0];
7294                         $database_name_out = kiriwrite_convert($database_name, "normal_display");
7295                         $messages = $messages . $information_prefix . "Compiling pages in the '" . $database_name_out . "' database..." . "<br>";
7296
7297                         # Get the pages in the database.
7298
7299                         $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_pages') or $messages = $messages . $error_prefix . "The database with the filename '" . $database_out . ".db' is in an invalid format. Skipping this database..." . "<br>", next;
7300                         $string_handle->execute();
7301
7302                         while(@databasepages = $string_handle->fetchrow_array()){
7303
7304                                 # Convert the values so that they can be
7305                                 # used in the messages list.
7306
7307                                 $page_filename          = $databasepages[0];
7308                                 $page_name              = $databasepages[1];
7309                                 $page_description       = $databasepages[2];
7310                                 $page_section           = $databasepages[3];
7311                                 $page_template          = $databasepages[4];
7312                                 $page_content           = $databasepages[5];
7313                                 $page_settings          = $databasepages[6];
7314                                 $page_lastmodified      = $databasepages[7];
7315
7316                                 $page_filename_out      = kiriwrite_convert($page_filename, "normal_display");
7317                                 $page_name_out          = kiriwrite_convert($page_name, "normal_display");
7318                                 $page_template_out      = kiriwrite_convert($page_template, "normal_display");
7319
7320                                 # Check if the filename is valid.
7321
7322                                 $page_filename_check = kiriwrite_variablecheck($page_filename, "page_filename");
7323
7324                                 if ($page_filename_check ne 0){
7325
7326                                         # The file name is not valid so write a
7327                                         # error and process the next page.
7328
7329                                         $messages = $messages . $error_prefix . "The page '" . $page_name_out . "' has an invalid filename. Page skipped." . "<br>";
7330                                         next;
7331
7332                                 }
7333
7334                                 # Check if the template with the filename does not exist
7335                                 # in the template files hash and write a message and
7336                                 # process the next page.
7337
7338                                 if (!$templatefiles{$page_template}{valid} && $page_template ne "!none" && $templates_skip eq 0){
7339
7340                                         $messages = $messages . $error_prefix . "The template with the filename '" . $page_template_out . "' for '" . $page_name_out . "' (" . $page_filename_out . ") does not exist." . "<br>";
7341                                         $error_count++;
7342                                         next;
7343
7344                                         $page_final = $page_content;
7345
7346                                 } elsif ($page_template eq "!none"){
7347
7348                                         $page_final = $page_content;
7349
7350                                 } else {
7351
7352                                         $page_final = $templatefiles{$page_template}{template};
7353                                         $page_final =~ s/<kiriwrite:pagecontent>/$page_content/g;
7354
7355                                 }
7356
7357                                 # Create the combined page title (if needed).
7358
7359                                 if ($page_settings eq 0){
7360
7361                                         # Don't use page name or section name.
7362
7363                                         $page_final =~ s/<kiriwrite:pagetitle>//g;
7364
7365                                 } elsif ($page_settings eq 1){
7366
7367                                         # Use the page name and section name.
7368
7369                                         $page_autotitle = "(" . $page_section . " - " . $page_name . ")";
7370                                         $page_title = $page_section . " - " . $page_name;
7371                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_title/g;
7372
7373                                 } elsif ($page_settings eq 2){
7374
7375                                         # Use the page name only.
7376
7377                                         $page_autotitle = "(" . $page_name . ")";
7378                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_name/g;
7379
7380                                 } elsif ($page_settings eq 3){
7381
7382                                         # Use the section name only.
7383
7384                                         if ($page_section){
7385                                                 $page_autotitle = "(" . $page_section . ")";
7386                                         }
7387                                         $page_final =~ s/<kiriwrite:pagetitle>/$page_section/g;
7388
7389                                 }
7390
7391                                 # Check if the section name is not blank and
7392                                 # place brackets inbetween if it is.
7393
7394                                 if ($page_section){
7395
7396                                         $page_autosection = "(" . $page_section . ")";
7397
7398                                 }
7399
7400                                 # Replace each <kiriwrite> value with the apporiate page
7401                                 # values.
7402
7403                                 $page_final =~ s/<kiriwrite:pagename>/$page_name/g;
7404                                 $page_final =~ s/<kiriwrite:pagedescription>/$page_description/g;
7405                                 $page_final =~ s/<kiriwrite:pagesection>/$page_section/g;
7406                                 $page_final =~ s/<kiriwrite:autosection>/$page_autosection/g;
7407                                 $page_final =~ s/<kiriwrite:autotitle>/$page_autotitle/g;
7408
7409                                 # Process the filters on the page data.
7410
7411                                 if ($filters_skip eq 0){
7412
7413                                         $filters_count = 0;
7414
7415                                         foreach $filter_find (@findfilter){
7416
7417                                                 # Get the replace filter and process each
7418                                                 # filter on the page.
7419
7420                                                 $filter_replace = $replacefilter[$filters_count];
7421                                                 $page_final =~ s/$filter_find/$filter_replace/g;
7422                                                 $filters_count++;
7423
7424                                         }
7425
7426                                 }
7427
7428                                 # Process the page filename and check what directories
7429                                 # need to be created.
7430
7431                                 $page_filename_length = int(length($page_filename));
7432
7433                                 do {
7434
7435                                         $page_filename_char = substr($page_filename, $page_filename_seek, 1);
7436
7437                                         # Check if a forward slash appears and add it to
7438                                         # the list of directories array.
7439
7440                                         if ($page_filename_char eq '/'){
7441
7442                                                 # Append the directory name to the list of
7443                                                 # directories array.
7444
7445                                                 $pagedirectories[$page_filename_dircount] = $page_filename_directory;
7446                                                 $page_filename_directory        = "";
7447                                                 $page_filename_char             = "";
7448                                                 $page_filename_dircount++;
7449
7450                                         } else {
7451
7452                                                 # Append the character to the directory/filename.
7453
7454                                                 $page_filename_directory = $page_filename_directory . $page_filename_char;
7455
7456                                         }
7457
7458                                         $page_filename_seek++;
7459
7460                                 } until ($page_filename_length eq $page_filename_seek);
7461
7462                                 foreach $page_directory_name (@pagedirectories){
7463
7464                                         # Check if the directory exists and create
7465                                         # the directory if it doesn't exist.
7466
7467                                         $page_directory_path = $page_directory_path . '/' . $page_directory_name;
7468
7469                                         mkdir($kiriwrite_config{"directory_data_output"} . '/' . $page_directory_path);
7470
7471                                 }
7472
7473                                 # Write the file to the output directory.
7474
7475                                 open(PAGE, "> " . $kiriwrite_config{"directory_data_output"} . '/' . $page_filename);
7476                                 print PAGE $page_final;
7477                                 close(PAGE);
7478
7479                                 # Write a message saying the page has been compiled.
7480
7481                                 $messages = $messages . $information_prefix . "'" . $page_name_out . "' (" . $page_filename_out . ") was compiled." . "<br>";
7482                                 $pages_count++;
7483
7484                                 # Reset certain values.
7485
7486                                 $page_autotitle = "";
7487                                 $page_autosection = "";
7488                                 $page_filename_seek = 0;
7489                                 $page_filename_dircount = 0;
7490
7491                                 $page_filename_directory = "";
7492                                 $page_directory_path = "";
7493                                 $page_directory_name = "";
7494                                 @pagedirectories = ();
7495
7496                         }
7497
7498                         # Write a message saying that the database has
7499                         # been processed.
7500
7501                         $messages = $messages . $information_prefix . "Finished compiling pages in the '" . $database_name_out . "' database..." . "<br>";
7502
7503                 }
7504
7505                 $messages = $messages . "<hr>";
7506                 $messages = $messages . $pages_count . " pages compiled, " . $error_count . " errors, " . $warning_count . " warnings.";
7507                 $pagedata = $pagedata . "<h2>Compile databases</h2>";
7508                 $pagedata = $pagedata . "<div class=\"datalist\">";
7509                 $pagedata = $pagedata . $messages;
7510                 $pagedata = $pagedata . "</div>";
7511
7512                 return $pagedata;
7513
7514         } elsif ($confirm eq 0){
7515
7516                 # The action to compile the databases has
7517                 # not been confirmed so check what type
7518                 # is being used.
7519
7520                 if ($type eq "single"){
7521
7522                         # The type is a single database selected so
7523                         # process that database.
7524
7525                         # Define some variables for later.
7526
7527                         my $database_handle;
7528                         my $string_handle;
7529                         my @database_info;
7530                         my $database_filename_check;
7531                         my $database_maxlength_check;
7532                         my $databasefilename;
7533                         my $databasefilename_out;
7534                         my $database_name;
7535                         my $database_name_out;
7536
7537                         # Check that the database name and length are
7538                         # valid and return an error if they aren't.
7539
7540                         $databasefilename = $selectedlist[0];
7541                         $databasefilename_out = kiriwrite_convert($databasefilename, "normal_display");
7542                         $database_filename_check        = kiriwrite_variablecheck($databasefilename, "filename", "", 1);
7543                         $database_maxlength_check       = kiriwrite_variablecheck($databasefilename, "maxlength", 64, 1);
7544
7545                         if ($database_filename_check ne 0){
7546
7547                                 # The database filename is invalid, so
7548                                 # return an error.
7549
7550                                 kiriwrite_error("databasefilenameinvalid");
7551
7552                         }
7553
7554                         if ($database_maxlength_check ne 0){
7555
7556                                 # The database filename is too long, so
7557                                 # return an error.
7558
7559                                 kiriwrite_error("databasefilenametoolong");
7560
7561                         }
7562
7563                         # Check if the database exists and has valid permissions
7564                         # set and skip them if they don't.
7565
7566                         my $database_exists             = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db');
7567                         my $database_permissions        = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db', 1, 0);
7568
7569                         if ($database_exists ne 0){
7570
7571                                 # The database filename does not exist, so
7572                                 # return an error.
7573
7574                                 kiriwrite_error("databasemissingfile");
7575
7576                         }
7577
7578                         if ($database_permissions ne 0){
7579
7580                                 # The database permissions are invalid, so
7581                                 # return an error.
7582
7583                                 kiriwrite_error("databaseinvalidpermissions");
7584
7585                         }
7586
7587                         # Load the SQLite database.
7588
7589                         $database_handle        = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $databasefilename . '.db');
7590
7591                         # Get the database name.
7592
7593                         $string_handle          = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1');
7594                         $string_handle->execute();
7595                         @database_info = $string_handle->fetchrow_array();
7596                         $database_name          = $database_info[0];
7597                         $database_name_out      = kiriwrite_convert($database_name, "normal_display");
7598
7599                         # Write out a form asking the user to confirm if the
7600                         # user wants to compile the selected database.
7601
7602                         $pagedata = $pagedata . "<h2>Compile database</h2>";
7603                         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
7604                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
7605                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
7606                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
7607                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"id[1]\" value=\"" . $databasefilename_out . "\">";
7608                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"name[1]\" value=\"on\">";
7609                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
7610                         $pagedata = $pagedata . "Are you sure you want to compile the '" . $database_name_out . "' database?<br><br>";
7611                         $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile database\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the list of databases for compiling.</a>";
7612                         $pagedata = $pagedata . "</form>";
7613
7614                         return $pagedata;
7615
7616                 } elsif ($type eq "multiple"){
7617
7618                         # The type is multiple databases selected
7619                         # so process each database.
7620
7621                         # Define some variables for later.
7622
7623                         my $database_handle;
7624                         my $databasename;
7625                         my $databasename_out;
7626                         my @database_info;
7627                         my $database_filename_check;
7628                         my $database_maxlength_check;
7629                         my $database_exists;
7630                         my $database_permissions;
7631                         my $database_count = 0;
7632                         my $string_handle;
7633                         my $database_info_name;
7634                         my $database_info_name_out;
7635                         my $databaselist = "";
7636
7637                         foreach $databasename (@selectedlist){
7638
7639                                 # Check if the database is in the database
7640                                 # directory and skip it if it isn't.
7641
7642                                 $database_filename_check        = kiriwrite_variablecheck($databasename, "filename", "", 1);
7643                                 $database_maxlength_check       = kiriwrite_variablecheck($databasename, "maxlength", 64, 1);
7644
7645                                 if ($database_filename_check ne 0 || $database_maxlength_check ne 0){
7646
7647                                         # The database filename given is invalid or
7648                                         # the database filename given is too long
7649                                         # so process the next database.
7650
7651                                         next;
7652
7653                                 }
7654
7655                                 # Check if the database exists and has valid permissions
7656                                 # set and skip them if they don't.
7657
7658                                 $database_exists        = kiriwrite_fileexists($kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db');
7659                                 $database_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db', 1, 0);
7660
7661                                 if ($database_exists ne 0 || $database_permissions ne 0){
7662
7663                                         # The database does not exist or the permissions
7664                                         # for the database are invalid so process the
7665                                         # next database.
7666
7667                                         next;
7668
7669                                 }
7670
7671                                 # Get the database name.
7672
7673                                 $database_handle = DBI->connect("dbi:SQLite:dbname=" . $kiriwrite_config{"directory_data_db"} . '/' . $databasename . '.db');
7674                                 $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or next;
7675                                 $string_handle->execute();
7676
7677                                 # Increment the amount of databases to compile.
7678
7679                                 $database_count++;
7680
7681                                 # Get the database name, convert it so that it can
7682                                 # be displayed properly and add it to the list of
7683                                 # databases to be compiled.
7684
7685                                 @database_info = $string_handle->fetchrow_array();
7686                                 $database_info_name = $database_info[0];
7687                                 $database_info_name_out = kiriwrite_convert($database_info_name, "normal_display");
7688                                 $databasename_out = kiriwrite_convert($databasename, "normal_display");
7689
7690                                 $databaselist = $databaselist . "<input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $databasename_out . "\"><input type=\"hidden\" name=\"name[" . $database_count . "]\" value=\"on\">" . $database_info_name_out . "<br>";
7691
7692                         }
7693
7694                         # Check if any databases are available to be compiled.
7695
7696                         if ($database_count eq 0){
7697
7698                                 # No databases are available to be compiled.
7699
7700                                 kiriwrite_error("nodatabaseselected");
7701
7702                         }
7703
7704                         # Write out the form for compiling the database.
7705
7706                         $pagedata = $pagedata . "<h2>Compile selected databases</h2>";
7707                         $pagedata = $pagedata . "Do you want to compile the following databases?<br><br>";
7708                         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
7709                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
7710                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
7711                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
7712                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
7713                         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
7714                         $pagedata = $pagedata . "<div class=\"datalist\">";
7715                         $pagedata = $pagedata . $databaselist;
7716                         $pagedata = $pagedata . "</div><br>";
7717                         $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile selected databases\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the database list.</a>";
7718                         $pagedata = $pagedata . "</form>";
7719
7720                         return $pagedata;
7721
7722                 } else {
7723
7724                         # The type is something else other than
7725                         # single or multiple, so return an error.
7726
7727                         kiriwrite_error("invalidvariable");
7728
7729                 }
7730
7731         } else {
7732
7733                 # The confirm value is neither 0 or 1, so
7734                 # return an error.
7735
7736                 kiriwrite_error("invalidvariable");
7737
7738         }
7739
7740 }
7741
7742 sub kiriwrite_compile_all{
7743 #################################################################################
7744 # kiriwrite_compile_all: Compile all of the databases in the database           #
7745 # directory.                                                                    #
7746 #                                                                               #
7747 # Usage:                                                                        #
7748 #                                                                               #
7749 # kiriwrite_compile_all();                                                      #
7750 #################################################################################
7751
7752         # Get the list of databases to compile.
7753
7754         opendir(DATABASE, $kiriwrite_config{"directory_data_db"});
7755         my @database_list = grep /m*\.db/, readdir(DATABASE);
7756         closedir(DATABASE);
7757
7758         # Define some variables for later.
7759
7760         my $databaseformdata;
7761         my $database_name               = "";
7762         my $database_name_filename_check;
7763         my $database_name_length        = 0;
7764         my $database_name_final_length  = 0;
7765         my $database_name_final         = "";
7766         my $database_count              = 1;
7767
7768         foreach $database_name (@database_list){
7769
7770                 # Check if the database filename is valid before
7771                 # using the database.
7772
7773                 $database_name_filename_check   = kiriwrite_variablecheck($database_name, "filename", 0, 1);
7774
7775                 if ($database_name_filename_check ne 0){
7776
7777                         # The database filename is invalid so process
7778                         # the next database.
7779
7780                         next;
7781
7782                 }
7783
7784                 # Get the database name without the extension.
7785
7786                 $database_name_length           = length($database_name);
7787                 $database_name_final_length     = $database_name_length - 3;
7788                 $database_name_final            = substr($database_name, 0, $database_name_final_length);
7789
7790                 # Process the final database name into form values.
7791
7792                 $databaseformdata = $databaseformdata . "<input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $database_name_final . "\">";
7793                 $databaseformdata = $databaseformdata . "<input type=\"hidden\" name=\"name[" . $database_count . "]\" value=\"on\">";
7794
7795                 $database_count++;
7796
7797         }
7798
7799         # Check the list of databases to compile to see if it is blank,
7800         # if it is then return an error.
7801
7802         if ($database_count eq 0){
7803
7804                 # The list of database is blank so return an error.
7805
7806                 kiriwrite_error("nodatabasesavailable");
7807
7808         }
7809
7810         # Write out a form for confirming the action to compile all of the databases.
7811
7812         my $pagedata = "<h2>Compile all databases</h2>";
7813         $pagedata = $pagedata . "Do you want to compile all of the databases in the database directory?<br><br>";
7814         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
7815         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
7816         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
7817         $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
7818         $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
7819         $pagedata = $pagedata . $databaseformdata;
7820         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
7821         $pagedata = $pagedata . "<input type=\"submit\" value=\"Compile all databases\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to the compile database list.</a>";
7822         $pagedata = $pagedata . "</form>";
7823
7824         return $pagedata;
7825
7826 }
7827
7828 sub kiriwrite_selectedlist{
7829 #################################################################################
7830 # kiriwrite_page_selectedlist: Get the list of selected pages to use.           #
7831 #                                                                               #
7832 # Usage:                                                                        #
7833 #                                                                               #
7834 # kiriwrite_page_selectedlist();                                                #
7835 #################################################################################
7836
7837         # Load the required Perl modules.
7838
7839         my $query = new CGI;
7840
7841         my $count       = $query->param('count');
7842
7843         # Check if the list of files has a value and if not set it 0.
7844
7845         if (!$count){
7846
7847                 $count = 0;
7848
7849         }
7850
7851         # Define some values for later.
7852
7853         my @filename_list;
7854         my @selected_list;
7855         my @final_list;
7856
7857         my $filename;
7858         my $selected;
7859
7860         my $final_count = 0;
7861         my $seek = 0;
7862
7863         # Get the list of filenames.
7864
7865         do {
7866
7867                 # Get the values from id[]
7868
7869                 $seek++;
7870
7871                 $filename               = $query->param('id[' . $seek . ']');
7872                 $filename_list[$seek]   = $filename;
7873
7874         } until ($seek eq $count || $count eq 0);
7875
7876         # Get the list of selected filenames.
7877
7878         $seek = 0;
7879
7880         do {
7881
7882                 # Get the values from name[]
7883
7884                 $seek++;
7885
7886                 $selected       = $query->param('name[' . $seek . ']');
7887
7888                 if (!$selected){
7889
7890                         $selected = 'off';
7891
7892                 }
7893
7894                 $selected_list[$seek]   = $selected;
7895
7896         } until ($seek eq $count || $count eq 0);
7897
7898         # Create a final list of filenames to be used for
7899         # processing.
7900
7901         $seek = 0;
7902
7903         do {
7904
7905                 # Check if the selected value is on and include
7906                 # the filename in the final list.
7907
7908                 $seek++;
7909
7910                 $selected       = $selected_list[$seek];
7911
7912                 if ($selected eq "on"){
7913
7914                         $filename       = $filename_list[$seek];
7915                         $final_list[$final_count] = $filename;
7916                         $final_count++;
7917
7918                 }
7919
7920         } until ($seek eq $count || $count eq 0);
7921
7922         return @final_list;
7923
7924 }
7925
7926 sub kiriwrite_compile_list{
7927 #################################################################################
7928 # kiriwrite_compile_list: Shows a list of databases that can be compiled.       #
7929 #                                                                               #
7930 # Usage:                                                                        #
7931 #                                                                               #
7932 # kiriwrite_compile_list();                                                     #
7933 #################################################################################
7934
7935         # Load the required Perl modules.
7936
7937         use DBI;
7938
7939         # Check the directory to make sure the permissions are settings are valid
7940         # and return an error if the permission settings are invalid.
7941
7942         my $data_directory_permissions = kiriwrite_filepermissions($kiriwrite_config{"directory_data_db"}, 1, 0);
7943
7944         if ($data_directory_permissions eq 1){
7945
7946                 # The data directory has invalid permissions set, so return an error.
7947
7948                 kiriwrite_error("datadirectoryinvalidpermissions");
7949
7950         }
7951
7952         # Open the directory and get the list of all files ending with .xml and
7953         # put them into the data_directory array.
7954
7955         opendir(DATADIR, $kiriwrite_config{"directory_data_db"});
7956         my @data_directory = grep /m*\.db/, readdir(DATADIR);
7957         closedir(DATADIR);
7958
7959         # Declare the following variables that are going to be used before using
7960         # the foreach function.
7961
7962         my $pagedata = "";
7963         my $database_count = 0;
7964         my $database_handle = "";
7965         my $database_filename = "";
7966         my $database_filename_friendly = "";
7967         my $database_filename_length = 0;
7968         my $database_permissions = "";
7969         my $database_name_out = "";
7970         my $database_description_out = "";
7971         my $data_file = "";
7972         my $string_handle = "";
7973         my @database_info;
7974         my $table_style = 0;
7975         my $table_style_name = "";
7976         my $tabledata = "";
7977         my $permissions_warning = 0;
7978         my $permissions_list = "";
7979         my $select_menu = "";
7980         my $invalid_warning = 0;
7981         my $invalid_list = "";
7982
7983         # Begin creating the table for the list of databases.
7984
7985         $pagedata = "<h2>Compile Pages</h2>\r\n";
7986         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
7987         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
7988         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"compile\">";
7989         $pagedata = $pagedata . "<input type=\"hidden\" name=\"type\" value=\"multiple\">";
7990
7991         $select_menu = "<input type=\"reset\" value=\"Select None\"> | <input type=\"submit\" value=\"Compile selected\">";
7992
7993         foreach $data_file (@data_directory){
7994                 # Check the database file permissions before opening it.
7995
7996                 $database_filename = $kiriwrite_config{"directory_data_db"} . '/' . $data_file;
7997                 $database_permissions = kiriwrite_filepermissions($database_filename, 1, 0, 0);
7998
7999                 if ($database_permissions eq 1){
8000                         $permissions_warning = 1;
8001                         $permissions_list = $permissions_list . $data_file . "<br>\r\n";
8002                         next;
8003                 }
8004
8005                 # Load the SQLite database.
8006
8007                 $database_handle = DBI->connect("dbi:SQLite:dbname=" . $database_filename);
8008
8009                 # Query the SQLite database or return an error (meaning that the database is in
8010                 # a invalid format).
8011
8012                 $string_handle = $database_handle->prepare('SELECT * FROM kiriwrite_database_info LIMIT 1') or (
8013                         $invalid_list = $invalid_list . $data_file . "<br>\r\n",
8014                         $invalid_warning = 1,
8015                         next
8016                 );
8017
8018                 $string_handle->execute();
8019                 @database_info = $string_handle->fetchrow_array();
8020
8021                 # Check the style to be used with.
8022
8023                 if ($table_style eq 0){
8024
8025                         # Use the first style and set the style value
8026                         # to use the next style, the next time the
8027                         # if statement is checked.
8028
8029                         $table_style_name = "tablecell1";
8030                         $table_style = 1;
8031                 } else {
8032
8033                         # Use the second style and set the style
8034                         # value to use the first style, the next
8035                         # time if statement is checked.
8036
8037                         $table_style_name = "tablecell2";
8038                         $table_style = 0;
8039                 }
8040
8041                 $database_name_out              = kiriwrite_convert($database_info[0], "normal_display");
8042                 $database_description_out       = kiriwrite_convert($database_info[1], "normal_display");
8043
8044                 # Create a friendly name for the database.
8045
8046                 $database_filename_length = length($data_file);
8047                 $database_filename_friendly = substr($data_file, 0, $database_filename_length - 3);
8048
8049                 $database_count++;
8050
8051                 # Append the database information to the table.
8052
8053                 $tabledata = $tabledata . "<tr><td class=\"" . $table_style_name . "\"><input type=\"hidden\" name=\"id[" . $database_count . "]\" value=\"" . $database_filename_friendly . "\"><input type=\"checkbox\" name=\"name[" . $database_count . "]\"></td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=page&action=view&database=" . $database_filename_friendly . "\">" . $database_name_out . "</a></td><td class=\"" . $table_style_name . "\">" . $database_description_out . "</td><td class=\"" . $table_style_name . "\"><a href=\"kiriwrite.cgi?mode=compile&action=compile&type=single&database=" . $database_filename_friendly . "\">Compile</a></td></tr>\r\n";
8054
8055         }
8056
8057         $pagedata = $pagedata . "<input type=\"hidden\" name=\"count\" value=\"" . $database_count . "\">";
8058
8059         $pagedata = $pagedata . $select_menu . "<br><br>";
8060
8061         $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\"><tr><td class=\"tablecellheader\"></td><td class=\"tablecellheader\">Database Name</td><td class=\"tablecellheader\">Database Description</td><td class=\"tablecellheader\">Options</td></tr>\r\n";
8062
8063         $pagedata = $pagedata . $tabledata;
8064
8065         $pagedata = $pagedata . "</table>\r\n<br />";
8066
8067         $pagedata = $pagedata . $select_menu;
8068         $pagedata = $pagedata . "</form>";
8069
8070         # Check if there are no valid databases are if there is no
8071         # valid databases then write a message saying that no
8072         # valid databases are available.
8073
8074         if ($database_count eq 0){
8075
8076                 #
8077
8078                 $pagedata = "<h2>Database List</h2><p>";
8079                 $pagedata = $pagedata . "<div class=\"errorbox\">There are no databases that can be used for compiling.</div><p>";
8080
8081         }
8082
8083         # Check if any databases with problems have appeared and if they
8084         # have, print out a message saying which databases have problems.
8085
8086         if ($permissions_warning eq 1){
8087
8088                 $pagedata = $pagedata . "<h4>Databases with invalid permissions</h4>";
8089                 $pagedata = $pagedata . "The following databases have invalid permissions set:<br><br>";
8090                 $pagedata = $pagedata . $permissions_list;
8091
8092         }
8093
8094         if ($invalid_warning eq 1){
8095
8096                 $pagedata = $pagedata . "<h4>Databases with invalid formats</h4>";
8097                 $pagedata = $pagedata . "The following databases are in a invalid format:<br><br>";
8098                 $pagedata = $pagedata . $invalid_list;
8099
8100         }
8101
8102         return $pagedata;
8103
8104 }
8105
8106 sub kiriwrite_compile_clean{
8107 #################################################################################
8108 # kiriwrite_compile_clean: Deletes the contents of the output directory.        #
8109 #                                                                               #
8110 # Usage:                                                                        #
8111 #                                                                               #
8112 # kiriwrite_compile_clean(confirm);                                             #
8113 #                                                                               #
8114 # confirm       Confirms the deletion of files from the output directory.       #
8115 #################################################################################
8116
8117         # Get the values passed to the subroutine.
8118
8119         my ($confirm) = @_;
8120
8121         # Define some variables for later.
8122
8123         my $file_permissions;
8124         my $output_directory_exists;
8125         my $output_directory_permissions;
8126         my $warning_message;
8127         my $pagedata = "";
8128
8129         # Check if the output directory exists.
8130
8131         $output_directory_exists         = kiriwrite_fileexists($kiriwrite_config{"directory_data_output"});
8132
8133         if ($output_directory_exists eq 1){
8134
8135                 # The output directory does not exist so return
8136                 # an error.
8137
8138                 kiriwrite_error("outputdirectorymissing");
8139
8140         }
8141
8142         # Check if the output directory has invalid
8143         # permissions set.
8144
8145         $output_directory_permissions   = kiriwrite_filepermissions($kiriwrite_config{"directory_data_output"});
8146
8147         if ($output_directory_permissions eq 1){
8148
8149                 # The output directory has invalid permissions
8150                 # set, so return an error.
8151
8152                 kiriwrite_error("outputdirectoryinvalidpermissions");
8153
8154         }
8155
8156         if ($confirm) {
8157
8158                 if ($confirm eq 1){
8159
8160                         # The action to clean the output directory has been
8161                         # confirmed.
8162
8163                         # Remove the list of files and directories from the
8164                         # output directory.
8165
8166                         $file_permissions = kiriwrite_compile_clean_helper($kiriwrite_config{"directory_data_output"}, 1);
8167
8168                         if ($file_permissions eq 1){
8169
8170                                 # One of the files or directories has invalid
8171                                 # permissions set so write a warning message.
8172
8173                         }
8174
8175                         $pagedata = "<h2>Clean Output Directory</h2>";
8176
8177                         if ($file_permissions eq 1){
8178
8179                                 $pagedata = $pagedata . "Some of the contents of the directory were removed. However, not all of the files in the output directory were deleted due to invalid permissions.<br><br>";
8180
8181                         } else {
8182
8183                                 $pagedata = $pagedata . "The contents of the output directory have been removed.<br><br>";
8184
8185                         }
8186
8187                         $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=compile\">Return to the compile databases list.</a>";
8188
8189                         return $pagedata;
8190
8191                 } else {
8192
8193                         # A value other than 1 is set for the confirm value
8194                         # (which it shouldn't be) so return an error.
8195
8196                         kiriwrite_error("invalidvariable");
8197
8198                 }
8199
8200         }
8201
8202         # Print out a form for cleaning the output directory.
8203
8204         $pagedata = "<h2>Clean Output Directory</h2>";
8205         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
8206         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"compile\">";
8207         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"clean\">";
8208         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
8209         $pagedata = $pagedata . "Are you sure you want to clean the output directory?<br><br>";
8210         $pagedata = $pagedata . "<input type=\"submit\" value=\"Yes, clean output directory\"> | <a href=\"kiriwrite.cgi?mode=compile\">Return to compile list.</a>";
8211         $pagedata = $pagedata . "</form>";
8212
8213         return $pagedata;
8214
8215 }
8216
8217 sub kiriwrite_compile_clean_helper{
8218 #################################################################################
8219 # kiriwrite_compile_clean_helper: Helper for cleaning out the output directory. #
8220 # This command sometimes is called recursively (when a directory is found).     #
8221 #                                                                               #
8222 # Usage:                                                                        #
8223 #                                                                               #
8224 # kiriwrite_compile_clean_helper(directory, removedirectory, [permissions]);    #
8225 #                                                                               #
8226 # directory             Specifies the directory to remove files (and            #
8227 #                       sub-directories) from.                                  #
8228 # keepdirectory         Keeps the directory itself after all files have been    #
8229 #                       removed.                                                #
8230 # permissions           Used recursively for error checking.                    #
8231 #################################################################################
8232
8233         # Get the values passed to the subroutine.
8234
8235         my ($directory, $directory_keep, $permissions) = @_;
8236
8237         # Check if the directory_keep is only one charater long.
8238
8239         my $directory_file = "";
8240         my @directory_list;
8241         my $file_permissions = 0;
8242         my $debug = 0;
8243
8244         # Check if the file permissions value is blank.
8245
8246         if (!$permissions){
8247
8248                 # The file permissions value is blank.
8249
8250                 $permissions = 0;
8251
8252         }
8253
8254         # Open the directory specified, read the contents of
8255         # the directory and then close the directory.
8256
8257         opendir(DIRECTORY, $directory);
8258         @directory_list = readdir(DIRECTORY);
8259         closedir(DIRECTORY);
8260
8261         # Remove each file and directory.
8262
8263         foreach $directory_file (@directory_list){
8264
8265                 # Check if the filename is '.' or '..' and if it
8266                 # is skip those files.
8267
8268                 if ($directory_file eq "." || $directory_file eq ".."){
8269
8270                         # The filename is '.' or '..' so skip processing
8271                         # these files.
8272
8273                 } else {
8274
8275                         # Check if the permissions on the file or directory has
8276                         # valid permissions set.
8277
8278                         $file_permissions = kiriwrite_filepermissions($directory . '/' . $directory_file, 1, 1);
8279
8280                         if ($file_permissions eq 1){
8281
8282                                 # The file or directory has invalid permissions set.
8283
8284                                 $permissions = 1;
8285                                 next;
8286
8287                         }
8288
8289                         # Check if the filename is a directory.
8290
8291                         if (-d $directory . '/' . $directory_file){
8292
8293                                 # The filename is a directory so send the directory name
8294                                 # and this subroutine again (recursively).
8295
8296                                 kiriwrite_compile_clean_helper($directory . '/' . $directory_file, 0, $permissions);
8297
8298                         } else {
8299
8300                                 # The file is not a directory but an actual file so
8301                                 # remove as normal (in terms of the Perl language).
8302
8303                                 ($directory) = $directory =~ m/^([a-zA-Z0-9\/.]+)$/ig;
8304                                 ($directory_file) = $directory_file =~ m/^([a-zA-Z0-9.]+)$/ig;
8305
8306                                 unlink($directory . '/' . $directory_file);
8307
8308                         }
8309
8310                 }
8311
8312         }
8313
8314         # Check if the directory should be kept.
8315
8316         if ($directory_keep eq 1){
8317
8318                 # The directory_keep value is set as 1 so the directory
8319                 # specified should be kept.
8320
8321         } elsif ($directory_keep eq 0) {
8322
8323                 # The directory_keep value is set as 0 so remove the
8324                 # directory specified.
8325
8326                 ($directory) = $directory =~ m/^([a-zA-Z0-9\/.]+)$/ig;
8327                 rmdir($directory);
8328
8329         } else {
8330
8331                 # A value other than 0 or 1 was specified so return
8332                 # an error,
8333
8334                 kiriwrite_error('invalidvalue');
8335
8336         }
8337
8338         return $permissions;
8339
8340 }
8341
8342 sub kiriwrite_settings_view{
8343 #################################################################################
8344 # kiriwrite_options_view: Writes out the list of options and variables.         #
8345 #                                                                               #
8346 # Usage:                                                                        #
8347 #                                                                               #
8348 # kiriwrite_settings_view();                                                    #
8349 #################################################################################
8350
8351         # Get the settings.
8352
8353         my $settings_directory_db       = $kiriwrite_config{"directory_data_db"};
8354         my $settings_directory_output   = $kiriwrite_config{"directory_data_output"};
8355         my $settings_noncgi_images      = $kiriwrite_config{"directory_noncgi_images"};
8356         my $settings_system_datetime    = $kiriwrite_config{"system_datetime"};
8357         my $settings_system_language    = $kiriwrite_config{"system_language"};
8358         my $settings_system_output      = $kiriwrite_config{"system_output"};
8359
8360         # CONTINUE: Write out convert things.
8361
8362         my $settings_directory_db_out           = kiriwrite_convert($settings_directory_db, "normal_display");
8363         my $settings_directory_output_out       = kiriwrite_convert($settings_directory_output, "normal_display");
8364         my $settings_noncgi_images_out          = kiriwrite_convert($settings_noncgi_images, "normal_display");
8365         my $settings_system_datetime_out        = kiriwrite_convert($settings_system_datetime, "normal_display");
8366         my $settings_system_language_out        = kiriwrite_convert($settings_system_language, "normal_display");
8367         my $settings_system_output_out          = kiriwrite_convert($settings_system_output, "normal_display");
8368
8369         my $pagedata = "<h2>View Settings</h2>";
8370
8371         $pagedata = $pagedata . "The current settings being used are the following:";
8372
8373         $pagedata = $pagedata . "<br><br><table cellpadding=\"5\" cellspacing=\"0\">";
8374         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Setting</td><td class=\"tablecellheader\">Value</td></tr>";
8375
8376         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Directories</td><td class=\"tablecellheader\"></td></tr>";
8377         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database Directory</td><td class=\"tablecell2\">" . $settings_directory_db_out . "</td></tr>";
8378         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output Directory</td><td class=\"tablecell2\">" . $settings_directory_output_out . "</td></tr>";
8379         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Images (URI path)</td><td class=\"tablecell2\">" . $settings_noncgi_images_out . "</td></tr>";
8380         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Date</td><td class=\"tablecellheader\"></td></tr>";
8381         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Date format</td><td class=\"tablecell2\">" . $settings_system_datetime_out . "</td></tr>";
8382         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Language</td><td class=\"tablecellheader\"></td></tr>";
8383         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">System Language</td><td class=\"tablecell2\">" . $settings_system_language_out . "</td></tr>";
8384         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Output</td><td class=\"tablecellheader\"></td></tr>";
8385         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output System</td><td class=\"tablecell2\">" . $settings_system_output_out . "</td></tr>";
8386         $pagedata = $pagedata . "</table><br>";
8387
8388         $pagedata = $pagedata . "To alter the current settings, select the Edit Settings option at the top of the page.";
8389
8390         return $pagedata;
8391
8392 }
8393
8394 sub kiriwrite_settings_edit{
8395 #################################################################################
8396 # kiriwrite_options_edit: Edits the options.                                    #
8397 #                                                                               #
8398 # Usage:                                                                        #
8399 #                                                                               #
8400 # kiriwrite_options_edit(dbdirectory, outputdirectory, imagesuri,               #
8401 #                       languagesystem, outputsystem, confirm);                 #
8402 #                                                                               #
8403 # dbdirectory           Specifies the new database directory to use.            #
8404 # outputdirectory       Specifies the new output directory to use.              #
8405 # imagesuri             Specifies the new URI path for images.                  #
8406 # datetimeformat        Specifies the new date and time format.                 #
8407 # languagesystem        Specifies the new language to use for Kiriwrite.        #
8408 # outputsystem          Specifies the new output system to use for Kiriwrite.   #
8409 # confirm               Confirms the action to edit the settings.               #
8410 #################################################################################
8411
8412         # Get the values that have been passed to the subroutine.
8413
8414         my ($settings_dbdirectory, $settings_outputdirectory, $settings_imagesuri, $settings_datetimeformat, $settings_languagesystem, $settings_outputsystem, $confirm) = @_;
8415
8416         # Load the required Perl modules.
8417
8418         my $xsl = XML::Simple->new();
8419
8420         if (!$confirm){
8421
8422                 # If the confirm value is blank, then set the confirm
8423                 # value to 0.
8424
8425                 $confirm = 0;
8426
8427         }
8428
8429         if ($confirm eq "1"){
8430
8431                 # The action to edit the settings has been confirmed.
8432                 # Start by checking each variable about to be placed
8433                 # in the settings file is valid.
8434
8435                 # Deinfe some variables for later.
8436
8437                 my @kiriwrite_new_settings;
8438
8439                 # Check the length of the directory names.
8440
8441                 kiriwrite_variablecheck($settings_dbdirectory, "maxlength", 64, 0);
8442                 kiriwrite_variablecheck($settings_outputdirectory, "maxlength", 64, 0);
8443                 kiriwrite_variablecheck($settings_imagesuri, "maxlength", 512, 0);
8444                 kiriwrite_variablecheck($settings_datetimeformat, "maxlength", 32, 0);
8445
8446                 kiriwrite_variablecheck($settings_languagesystem, "language_filename", "", 0);
8447                 kiriwrite_variablecheck($settings_outputsystem, "outputmodule", 0, 1);
8448
8449                 # Check if the directory names only contain letters and numbers and
8450                 # return a specific error if they don't.
8451
8452                 my $kiriwrite_dbdirectory_check         = kiriwrite_variablecheck($settings_dbdirectory, "directory", 0, 1);
8453                 my $kiriwrite_outputdirectory_check     = kiriwrite_variablecheck($settings_outputdirectory, "directory", 0, 1);
8454                 kiriwrite_variablecheck($settings_datetimeformat, "datetime", 0, 0);
8455
8456                 if ($kiriwrite_dbdirectory_check eq 1){
8457
8458                         # The database directory name is blank, so return
8459                         # an error.
8460
8461                         kiriwrite_error("dbdirectoryblank");
8462
8463                 } elsif ($kiriwrite_dbdirectory_check eq 2){
8464
8465                         # The database directory name is invalid, so return
8466                         # an error.
8467
8468                         kiriwrite_error("dbdirectoryinvalid");
8469
8470                 }
8471
8472                 if ($kiriwrite_outputdirectory_check eq 1){
8473
8474                         # The output directory name is blank, so return
8475                         # an error.
8476
8477                         kiriwrite_error("outputdirectoryblank");
8478
8479                 } elsif ($kiriwrite_outputdirectory_check eq 2){
8480
8481                         # The output directory name is invalid, so return
8482                         # an error.
8483
8484                         kiriwrite_error("outputdirectoryinvalid");
8485
8486                 }
8487
8488                 # Place the settings into the array.
8489
8490                 $kiriwrite_new_settings[0] = $settings_dbdirectory;
8491                 $kiriwrite_new_settings[1] = $settings_outputdirectory;
8492                 $kiriwrite_new_settings[2] = $settings_imagesuri;
8493                 $kiriwrite_new_settings[3] = $settings_datetimeformat;
8494                 $kiriwrite_new_settings[4] = $settings_languagesystem;
8495                 $kiriwrite_new_settings[5] = $settings_outputsystem;
8496
8497                 # Write the new settings to the XML file.
8498
8499                 kiriwrite_output_xml("kiriwrite.xml", "config", @kiriwrite_new_settings);
8500
8501                 # Write a confirmation message.
8502
8503                 my $pagedata = "<h2>Edit Settings</h2>";
8504                 $pagedata = $pagedata . "The page settings have been changed and will take effect on the next page load of Kiriwrite.<br><br>";
8505                 $pagedata = $pagedata . "<a href=\"kiriwrite.cgi?mode=settings\">Return to the list of settings.</a>";
8506
8507                 return $pagedata;
8508
8509         }
8510
8511         # Get the list of languages available.
8512
8513         my @language_directory          = "";
8514         my $language_filename           = "";
8515         my $language_file_xml           = "";
8516         my $language_file_systemname    = "";
8517         my $language_file_localname     = "";
8518         my $language_file_localname_out = "";
8519         my $language_file_seek          = 0;
8520         my $language_flie_dot           = 0;
8521         my $language_file_length        = 0;
8522         my $language_file_char          = "";
8523         my $language_file_friendly      = "";
8524         my $language_selectlist         = "";
8525
8526         opendir(LANGUAGEDIR, "lang");
8527         @language_directory = grep /m*\.xml/, readdir(LANGUAGEDIR);
8528         closedir(LANGUAGEDIR);
8529
8530         # Process each language by loading the XML configuration file
8531         # used for each language and then get the System name and
8532         # the local name of the language.
8533
8534         $language_selectlist = "<select name=\"language\">";
8535
8536         foreach $language_filename (@language_directory){
8537
8538                 # Load the language file currently selected.
8539
8540                 $language_file_xml = $xsl->XMLin("lang" . '/' . $language_filename, SuppressEmpty => 1);
8541
8542                 # Get the system name and the local name of the language.
8543
8544                 $language_file_localname = $language_file_xml -> {about} -> {name};
8545
8546                 # Check if either the system name or the local name of the language
8547                 # is blank and if it is, then don't add the language to the list.
8548
8549                 if ($language_file_localname eq ""){
8550
8551                         # The system name or the local name is blank so don't add
8552                         # the language to the list.
8553
8554                 } else {
8555
8556                         # Get the 'friendly' name of the language file name (basically
8557                         # remove the .xml part from the filename.
8558
8559                         $language_file_length = length($language_filename);
8560
8561                         do {
8562
8563                                 # Get a character from the language filename and currently
8564                                 # set by the seek counter.
8565
8566                                 $language_file_char = substr($language_filename, $language_file_seek, 1);
8567
8568                                 # Check if the character is a dot and if it is then set the
8569                                 # last dot value to the seek counter value.
8570
8571                                 if ($language_file_char eq "."){
8572
8573                                         # Current chatacter is a dot so set the last dot value
8574                                         # to what is currently the seek counter.
8575
8576                                         $language_flie_dot = $language_file_seek;
8577
8578                                 } else {
8579
8580                                         # Current character is not a dot, so do nothing.
8581
8582                                 }
8583
8584                                 # Increment the seek counter.
8585
8586                                 $language_file_seek++;
8587
8588                         } until ($language_file_seek eq $language_file_length);
8589
8590                         # Reset the seek counter.
8591
8592                         $language_file_seek = 0;
8593
8594                         # Process the file name again and this time process the file
8595                         # name until it reaches the last dot found.
8596
8597                         do {
8598
8599                                 # Get the character the seek counter is currently set at.
8600
8601                                 $language_file_char = substr($language_filename, $language_file_seek, 1);
8602
8603                                 # Append the character to the friendly file name.
8604
8605                                 $language_file_friendly = $language_file_friendly . $language_file_char;
8606
8607                                 # Increment the seek counter.
8608
8609                                 $language_file_seek++;
8610
8611                         } until ($language_file_seek eq $language_flie_dot);
8612
8613                         # Append the language to the available languages list.
8614
8615                         $language_file_localname_out = kiriwrite_convert($language_file_localname, "normal_display");
8616                         $language_selectlist = $language_selectlist . "<option value=\"" . $language_file_friendly . "\">" . $language_file_localname_out . "</option>";
8617
8618                         # Reset certain counters and values before continuing.
8619
8620                         $language_file_seek     = 0;
8621                         $language_flie_dot      = 0;
8622                         $language_file_length   = 0;
8623                         $language_file_char     = "";
8624                         $language_file_friendly = "";
8625
8626                 }
8627
8628         }
8629
8630         $language_selectlist = $language_selectlist . "</select>";
8631
8632         # Get the list of output systems available.
8633
8634         my @outputsys_directory         = "";
8635         my $outputsys_file              = "";
8636         my $outputsys_char              = "";
8637         my $outputsys_dot               = 0;
8638         my $outputsys_firstdot          = 0;
8639         my $outputsys_firstdotfound     = "";
8640         my $outputsys_seek              = 0;
8641         my $outputsys_length            = 0;
8642         my $outputsys_friendly          = "";
8643         my $outputsys_selectlist        = "";
8644         my $outputsys_config            = $kiriwrite_config{"system_output"};
8645
8646         # Open and get the list of output systems (perl modules) by filtering
8647         # out the
8648
8649         opendir(OUTPUTSYSTEMDIR, "Modules/Output");
8650         @outputsys_directory = grep /m*\.pm/, readdir(OUTPUTSYSTEMDIR);
8651         closedir(OUTPUTSYSTEMDIR);
8652
8653         $outputsys_selectlist = "<select name=\"outputsys\">";
8654
8655         # Process each output system and add them to the list of available
8656         # output systems.
8657
8658         foreach $outputsys_file (@outputsys_directory){
8659
8660                 # Get the length of the output system (perl module) filename.
8661
8662                 $outputsys_length = length($outputsys_file);
8663
8664                 # Get the friendly name of the Perl module (by getting rid of the
8665                 # .pm part of the filename).
8666
8667                 do {
8668
8669                         $outputsys_char = substr($outputsys_file, $outputsys_seek, 1);
8670
8671                         # Check if the current character is a dot and if it is then
8672                         # set the last dot found number to the current seek number.
8673
8674                         if ($outputsys_char eq "."){
8675
8676                                 # Put the seek value as the last dot found number.
8677
8678                                 $outputsys_dot = $outputsys_seek;
8679
8680                         }
8681
8682                         # Increment the seek counter.
8683
8684                         $outputsys_seek++;
8685
8686                 } until ($outputsys_seek eq $outputsys_length);
8687
8688                 # Reset the seek counter as it is going to be used again.
8689
8690                 $outputsys_seek = 0;
8691
8692                 # Get the friendly name of the Perl module by the processing the file
8693                 # name to the last dot the previous 'do' tried to find.
8694
8695                 do {
8696
8697                         # Get the character the seek counter is currently set at.
8698
8699                         $outputsys_char = substr($outputsys_file, $outputsys_seek, 1);
8700
8701                         # Append the character to the friendly name of the output system.
8702
8703                         $outputsys_friendly = $outputsys_friendly . $outputsys_char;
8704
8705                         # Increment the seek counter.
8706
8707                         $outputsys_seek++;
8708
8709                 } until ($outputsys_seek eq $outputsys_dot);
8710
8711                 # Append the option to tbe list of available output systems.
8712
8713                 # Check if the current friendly output module name matches with the
8714                 # output module name used in the configuration file.
8715
8716                 if ($outputsys_friendly eq $outputsys_config){
8717
8718                         # The output module friendly name matches with the output
8719                         # module name used in the configuration file.
8720
8721                         $outputsys_selectlist = $outputsys_selectlist . "<option value=\"" . $outputsys_friendly . "\" selected>" . $outputsys_friendly . "</option>";
8722
8723                 } else {
8724
8725                         # The output module friendly name does not match with the
8726                         # output module name used in the configuration file.
8727
8728                         $outputsys_selectlist = $outputsys_selectlist . "<option value=\"" . $outputsys_friendly . "\">" . $outputsys_friendly . "</option>";
8729
8730                 }
8731
8732                 # Reset the following values.
8733
8734                 $outputsys_seek         = 0;
8735                 $outputsys_length       = 0;
8736                 $outputsys_char         = "";
8737                 $outputsys_friendly     = "";
8738
8739
8740         }
8741
8742         $outputsys_selectlist = $outputsys_selectlist . "</select>";
8743
8744         # Get the directory settings.
8745
8746         my $directory_settings_database                 = $kiriwrite_config{"directory_data_db"};
8747         my $directory_settings_output                   = $kiriwrite_config{"directory_data_output"};
8748         my $directory_settings_imagesuri                = $kiriwrite_config{"directory_noncgi_images"};
8749         my $datetime_setting                            = $kiriwrite_config{"system_datetime"};
8750
8751         my $directory_settings_database_out             = kiriwrite_convert($directory_settings_database, "normal_display");
8752         my $directory_settings_output_out               = kiriwrite_convert($directory_settings_output, "normal_display");
8753         my $directory_settings_imagesuri_out            = kiriwrite_convert($directory_settings_imagesuri, "normal_display");
8754         my $datetime_setting_out                        = kiriwrite_convert($datetime_setting, "normal_display");
8755
8756         # Print out a form for editing the settings.
8757
8758         my $pagedata = "<h2>Edit Settings</h2>";
8759         $pagedata = $pagedata . "<b>Warning:</b> Settings that have changed take effect after clicking on the 'Change Settings' button and viewing the confirmation message.<br><br>";
8760
8761         $pagedata = $pagedata . "<form action=\"kiriwrite.cgi\" method=\"POST\">";
8762         $pagedata = $pagedata . "<input type=\"hidden\" name=\"mode\" value=\"settings\">";
8763         $pagedata = $pagedata . "<input type=\"hidden\" name=\"action\" value=\"edit\">";
8764         $pagedata = $pagedata . "<input type=\"hidden\" name=\"confirm\" value=\"1\">";
8765         $pagedata = $pagedata . "<table cellpadding=\"5\" cellspacing=\"0\">";
8766         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Directories</td><td class=\"tablecellheader\"></td></tr>";
8767         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Database Directory</td><td class=\"tablecell2\"><input type=\"text\" name=\"databasedir\" value=\"" . $directory_settings_database_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
8768         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output Directory</td><td class=\"tablecell2\"><input type=\"text\" name=\"outputdir\" value=\"" . $directory_settings_output_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
8769         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Images (URI path)</td><td class=\"tablecell2\"><input type=\"text\" name=\"imagesuripath\" value=\"" . $directory_settings_imagesuri_out . "\" size=\"32\" maxlength=\"64\"></td></tr>";
8770         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Date</td><td class=\"tablecellheader\"></td></tr>";
8771         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Date format</td><td class=\"tablecell2\"><input type=\"text\" name=\"datetime\" value=\"" . $datetime_setting_out . "\" size=\"32\" maxlength=\"32\"><br><br>";
8772         $pagedata = $pagedata . "<div class=\"datalist\">D - Show single digit day if day value is less than 10.<br>
8773         DD - Show double digit day if day value is less than 10.<br>
8774         M - Show single digit month if month value is less than 10.<br>
8775         MM - Show double digit month if month value is less than 10.<br>
8776         Y - Show double digit year value.<br>
8777         YY - Show four digit year value.<br><br>
8778         h - Show single digit hour if hour value is less than 10.<br>
8779         hh - Show double digit hour if hour value is less than 10.<br>
8780         m - Show single digit minute if minute value is less than 10.<br>
8781         mm - Show double digit minute if minute value is less than 10.<br>
8782         s - Show single digit second if second value is less than 10.<br>
8783         ss - Show double digit second if second value is less than 10.<br><br>
8784         Other Characters: / - ( ) :
8785         </div>";
8786         $pagedata = $pagedata . "</td></tr>";
8787         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Languages</td><td class=\"tablecellheader\"></td></tr>";
8788         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">System Language</td><td class=\"tablecell2\">" . $language_selectlist . "</td></tr>";
8789         $pagedata = $pagedata . "<tr><td class=\"tablecellheader\">Output</td><td class=\"tablecellheader\"></td></tr>";
8790         $pagedata = $pagedata . "<tr><td class=\"tablecell1\">Output System</td><td class=\"tablecell2\">" . $outputsys_selectlist . "</td></tr>";
8791         $pagedata = $pagedata . "</table><br>";
8792         $pagedata = $pagedata . "<input type=\"submit\" value=\"Change Settings\"> | <input type=\"reset\" value=\"Revert Settings\">";
8793         $pagedata = $pagedata . "</form>";
8794
8795         return $pagedata;
8796
8797 }
8798
8799 sub kiriwrite_settings_load{
8800 #################################################################################
8801 # kiriwrite_settings_load: Load the configuration settings into the global      #
8802 # variables.                                                                    #
8803 #                                                                               #
8804 # Usage:                                                                        #
8805 #                                                                               #
8806 # kiriwrite_settings_load();                                                    #
8807 #################################################################################
8808
8809         # Load the required Perl modules.
8810
8811         use XML::Simple;
8812         my $xsl = XML::Simple->new();
8813
8814         # Check if the Kiriwrite configuration file exists before using it and
8815         # return a critical error if it doesn't exist.
8816
8817         my $kiriwrite_conf_exist = kiriwrite_fileexists("kiriwrite.xml");
8818
8819         if ($kiriwrite_conf_exist eq 1){
8820
8821                 # The configuration really does not exist so return an critical error.
8822
8823                 kiriwrite_critical("configfilemissing");
8824
8825         }
8826
8827         # Check if the Kiriwrite configuration file has valid permission settings
8828         # before using it and return a critical error if it doesn't have the
8829         # valid permission settings.
8830
8831         my $kiriwrite_conf_permissions = kiriwrite_filepermissions("kiriwrite.xml", 1, 0);
8832
8833         if ($kiriwrite_conf_permissions eq 1){
8834
8835                 # The permission settings for the Kiriwrite configuration file are
8836                 # invalid, so return an critical error.
8837
8838                 kiriwrite_critical("configfileinvalidpermissions");
8839
8840         }
8841
8842         # Converts the XML file into meaningful data for later on in this subroutine.
8843
8844         my $kiriwrite_conf_file = 'kiriwrite.xml';
8845         my $kiriwrite_conf_data = $xsl->XMLin($kiriwrite_conf_file, SuppressEmpty => 1);
8846
8847         # Go and fetch the settings and place them into a hash (that is global).
8848
8849         %kiriwrite_config = (
8850
8851                 "directory_data_db"             => $kiriwrite_conf_data->{settings}->{directories}->{database},
8852                 "directory_data_output"         => $kiriwrite_conf_data->{settings}->{directories}->{output},
8853                 "directory_noncgi_images"       => $kiriwrite_conf_data->{settings}->{directories}->{images},
8854
8855                 "system_language"               => $kiriwrite_conf_data->{settings}->{language}->{type},
8856                 "system_output"                 => $kiriwrite_conf_data->{settings}->{system}->{output},
8857                 "system_datetime"               => $kiriwrite_conf_data->{settings}->{system}->{datetime}
8858
8859         );
8860
8861         # Do a validation check on all of the variables that were loaded into the global configuration hash.
8862
8863         kiriwrite_variablecheck($kiriwrite_config{"directory_data_db"}, "maxlength", 64, 0);
8864         kiriwrite_variablecheck($kiriwrite_config{"directory_data_output"}, "maxlength", 64, 0);
8865         kiriwrite_variablecheck($kiriwrite_config{"directory_noncgi_images"}, "maxlength", 512, 0);
8866         kiriwrite_variablecheck($kiriwrite_config{"directory_data_template"}, "maxlength", 64, 0);
8867
8868         kiriwrite_variablecheck($kiriwrite_config{"system_language"}, "language_filename", "", 0);
8869         kiriwrite_variablecheck($kiriwrite_config{"system_output"}, "outputmodule", 0, 0);
8870
8871         # Check if the output system module does exist before loading it and return an critical error
8872         # if the output system module does not exist.
8873
8874         my $kiriwrite_config_systemoutput_fileexists = kiriwrite_fileexists("Modules/Output/" . $kiriwrite_config{"system_output"} . ".pm");
8875
8876         if ($kiriwrite_config_systemoutput_fileexists eq 1){
8877
8878                 # Output system module does not exist so return an critical error.
8879
8880                 kiriwrite_critical("outputsystemmissing");
8881
8882         }
8883
8884         # Check if the output system module does have the valid permission settings and return an
8885         # critical error if the output system module contains invalid permission settings.
8886
8887         my $kiriwrite_config_systemoutput_permissions = kiriwrite_filepermissions("Modules/Output/" . $kiriwrite_config{"system_output"} . ".pm", 1, 0);
8888
8889         if ($kiriwrite_config_systemoutput_permissions eq 1){
8890
8891                 # Output system contains invalid permissions so return an critical error.
8892
8893                 kiriwrite_critical("outputsysteminvalidpermissions");
8894
8895         }
8896
8897         return;
8898
8899 }
8900
8901 sub kiriwrite_variablecheck{
8902 #################################################################################
8903 # kiriwrite_variablecheck: Checks the variables for any invalid characters.     #
8904 #                                                                               #
8905 # Usage:                                                                        #
8906 #                                                                               #
8907 # kiriwrite_variablecheck(variablename, type, length, noerror);                 #
8908 #                                                                               #
8909 # variablename  Specifies the variable to be checked.                           #
8910 # type          Specifies what type the variable is.                            #
8911 # option        Specifies the maximum/minimum length of the variable            #
8912 #               (if minlength/maxlength is used) or if the filename should be   #
8913 #               checked to see if it is blank.                                  #
8914 # noerror       Specifies if Kiriwrite should return an error or not on         #
8915 #               certain values.                                                 #
8916 #################################################################################
8917
8918         # Get the values that were passed to the subroutine.
8919
8920         my ($variable_data, $variable_type, $variable_option, $variable_noerror) = @_;
8921
8922         if ($variable_type eq "numbers"){
8923
8924                 # Check for numbers and return an error if there is anything else than numebrs.
8925
8926                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated.
8927                 $variable_data_validated =~ tr/0-9//d;          # Take away all of the numbers and from the variable.
8928                                                                 # If it only contains numbers then it should be blank.
8929
8930                 if ($variable_data_validated eq ""){
8931                         # The validated variable is blank. So continue to the end of this section where the return function should be.
8932                 } else {
8933                         # The variable is not blank, so check if the no error value is set
8934                         # to 1 or not.
8935
8936                         if ($variable_noerror eq 1){
8937
8938                                 # The validated variable is not blank and the noerror
8939                                 # value is set to 1. So return an value of 1.
8940                                 # (meaning that the data is invalid).
8941
8942                                 return 1;
8943
8944                         } elsif ($variable_noerror eq 0) {
8945
8946                                 # The validated variable is not blank and the noerror
8947                                 # value is set to 0.
8948
8949                                 kiriwrite_error("invalidvariable");
8950
8951                         } else {
8952
8953                                 # The variable noerror value is something else
8954                                 # pther than 1 or 0. So return an error.
8955
8956                                 kiriwrite_error("invalidvariable");
8957
8958                         }
8959
8960                 }
8961
8962                 return 0;
8963
8964         } elsif ($variable_type eq "lettersnumbers"){
8965
8966                 # Check for letters and numbers and return an error if there is anything else other
8967                 # than letters and numbers.
8968
8969                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated
8970                 $variable_data_validated =~ tr/a-zA-Z0-9.//d;
8971                 $variable_data_validated =~ s/\s//g;
8972
8973                 if ($variable_data_validated eq ""){
8974                         # The validated variable is blank. So continue to the end of this section where the return function should be.
8975                 } else {
8976                         # The variable is not blank, so check if the no error value is set
8977                         # to 1 or not.
8978
8979                         if ($variable_noerror eq 1){
8980
8981                                 # The validated variable is not blank and the noerror
8982                                 # value is set to 1. So return an value of 1.
8983                                 # (meaning that the data is invalid).
8984
8985                                 return 1;
8986
8987                         } elsif ($variable_noerror eq 0) {
8988
8989                                 # The validated variable is not blank and the noerror
8990                                 # value is set to 0.
8991
8992                                 kiriwrite_error("invalidvariable");
8993
8994                         } else {
8995
8996                                 # The variable noerror value is something else
8997                                 # pther than 1 or 0. So return an error.
8998
8999                                 kiriwrite_error("invalidvariable");
9000
9001                         }
9002
9003                 }
9004
9005                 return 0;
9006
9007         } elsif ($variable_type eq "maxlength"){
9008                 # Check for the length of the variable, return an error if it is longer than the length specified.
9009
9010                 # Check if the variable_data string is blank, if it is then set the variable_data_length
9011                 # to '0'.
9012
9013                 my $variable_data_length = 0;
9014
9015                 if (!$variable_data){
9016
9017                         # Set variable_data_length to '0'.
9018                         $variable_data_length = 0;
9019
9020                 } else {
9021
9022                         # Get the length of the variable recieved.
9023                         $variable_data_length = length($variable_data);
9024
9025                 }
9026
9027
9028
9029                 if ($variable_data_length > $variable_option){
9030
9031                         # The variable length is longer than it should be so check if
9032                         # the no error value is set 1.
9033
9034                         if ($variable_noerror eq 1){
9035
9036                                 # The no error value is set to 1, so return an
9037                                 # value of 1 (meaning tha the variable is
9038                                 # too long to be used).
9039
9040                                 return 1;
9041
9042                         } elsif ($variable_noerror eq 0){
9043
9044                                 # The no error value is set to 0, so return
9045                                 # an error.
9046
9047                                 kiriwrite_error("variabletoolong");
9048
9049                         } else {
9050
9051                                 # The no error value is something else other
9052                                 # than 0 or 1, so return an error.
9053
9054                                 kiriwrite_error("variabletoolong");
9055
9056                         }
9057
9058                 } else {
9059
9060                         # The variable length is exactly or shorter than specified, so continue to end of this section where
9061                         # the return function should be.
9062
9063                 }
9064
9065                 return 0;
9066
9067         } elsif ($variable_type eq "blank"){
9068                 # Check if the variable is blank and if it is blank, then return an error.
9069
9070                 if (!$variable_data){
9071
9072                         # The variable data really is blank, so check what
9073                         # the no error value is set.
9074
9075                         if ($variable_noerror eq 1){
9076
9077                                 # The no error value is set to 1, so return
9078                                 # a value of 1 (saying that the variable was
9079                                 # blank).
9080
9081                                 return 1;
9082
9083                         } elsif ($variable_noerror eq 0){
9084
9085                                 # The no error value is set to 0, so return
9086                                 # an error.
9087
9088                                 kiriwrite_error("blankvariable");
9089
9090                         } else {
9091
9092                                 # The no error value is something else other
9093                                 # than 0 or 1, so return an error.
9094
9095                                 kiriwrite_error("invalidvariable");
9096
9097                         }
9098
9099                 }
9100
9101                 return 0;
9102
9103         } elsif ($variable_type eq "filename"){
9104                 # Check for letters and numbers, if anything else than letters and numbers is there (including spaces) return
9105                 # an error.
9106
9107                 # Check if the filename passed is blank, if it is then return with an error.
9108
9109                 if ($variable_data eq ""){
9110
9111                         # The filename specified is blank, so check what the
9112                         # noerror value is set.
9113
9114                         if ($variable_noerror eq 1){
9115
9116                                 # The no error value is set to 1 so return
9117                                 # a value of 1 (meaning that the filename
9118                                 # was blank).
9119
9120                                 return 1;
9121
9122                         } elsif ($variable_noerror eq 0){
9123
9124                                 # The no error value is set to 1 so return
9125                                 # an error.
9126
9127                                 kiriwrite_error("blankfilename");
9128
9129                         } else {
9130
9131                                 # The no error value is something else other
9132                                 # than 0 or 1, so return an error.
9133
9134                                 kiriwrite_error("invalidvariable");
9135
9136                         }
9137
9138                 } else {
9139
9140
9141                 }
9142
9143                 my $variable_data_validated = $variable_data;
9144                 $variable_data_validated =~ tr/a-zA-Z0-9\.//d;
9145
9146                 # Check if the validated data variable is blank, if it is
9147                 # then continue to the end of this section where the return
9148                 # function should be, otherwise return an error.
9149
9150                 if ($variable_data_validated eq ""){
9151
9152                         # The validated data variable is blank, meaning that
9153                         # it only contained letters and numbers.
9154
9155                 } else {
9156
9157                         # The validated data variable is not blank, meaning
9158                         # that it contains something else, so return an error
9159                         # (or a value).
9160
9161                         if ($variable_noerror eq 1){
9162
9163                                 # The no error value is set to 1 so return
9164                                 # an value of 2. (meaning that the filename
9165                                 # is invalid).
9166
9167
9168                                 return 2;
9169
9170                         } elsif ($variable_noerror eq 0){
9171
9172                                 # The no error value is set to 0 so return
9173                                 # an error.
9174
9175                                 kiriwrite_error("invalidfilename");
9176
9177                         } else {
9178
9179                                 # The no error value is something else other
9180                                 # than 0 or 1 so return an error.
9181
9182                                 kiriwrite_error("invalidvariable");
9183
9184                         }
9185
9186                 }
9187
9188                 return 0;
9189
9190         } elsif ($variable_type eq "filenameindir"){
9191                 # Check if the filename is in the directory and return an
9192                 # error if it isn't.
9193
9194                 if ($variable_data eq ""){
9195
9196                         # The filename specified is blank, so check what the
9197                         # noerror value is set.
9198
9199                         if ($variable_noerror eq 1){
9200
9201                                 # The no error value is set to 1 so return
9202                                 # a value of 1 (meaning that the filename
9203                                 # was blank).
9204
9205                                 return 1;
9206
9207                         } elsif ($variable_noerror eq 0){
9208
9209                                 # The no error value is set to 1 so return
9210                                 # an error.
9211
9212                                 kiriwrite_error("blankfilename");
9213
9214                         } else {
9215
9216                                 # The no error value is something else other
9217                                 # than 0 or 1, so return an error.
9218
9219                                 kiriwrite_error("invalidvariable");
9220
9221                         }
9222
9223                 } else {
9224
9225
9226                 }
9227
9228                 # Set the following variables for later on.
9229
9230                 my $variable_data_length = 0;
9231                 my $variable_data_char = "";
9232                 my $variable_data_validated = "";
9233                 my $variable_data_seek = 0;
9234                 my $variable_data_directory = "";
9235                 my $variable_data_directorycurrent = "";
9236                 my $variable_data_firstlevel = 1;
9237
9238                 # Get the length of the variable recieved.
9239
9240                 $variable_data_length = length($variable_data);
9241
9242                 # Check if the database filename contains the directory command
9243                 # for up a directory level and if it is, return an error
9244                 # or return with a number.
9245
9246                 do {
9247
9248                         # Get a character from the filename passed to this subroutine.
9249
9250                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
9251
9252                         # Check if the current character is the forward slash character.
9253
9254                         if ($variable_data_char eq "/"){
9255
9256                                 # Check if the current directory is blank (and on the first level), or if the
9257                                 # current directory contains two dots or one dot, if it does return an error.
9258
9259                                 if ($variable_data_directorycurrent eq "" && $variable_data_firstlevel eq 1 || $variable_data_directorycurrent eq ".." || $variable_data_directorycurrent eq "."){
9260
9261                                         # Check if the noerror value is set to 1, if it is return an
9262                                         # number, else return an proper error.
9263
9264                                         if ($variable_noerror eq 1){
9265
9266                                                 # Page filename contains invalid characters and
9267                                                 # the no error value is set to 1 so return a
9268                                                 # value of 2 (meaning that the page filename
9269                                                 # is invalid).
9270
9271                                                 return 2;
9272
9273                                         } elsif ($variable_noerror eq 0) {
9274
9275                                                 # Page filename contains invalid characters and
9276                                                 # the no error value is set to 0 so return an
9277                                                 # error.
9278
9279                                                 kiriwrite_error("invalidfilename");
9280
9281                                         } else {
9282
9283                                                 # The no error value is something else other
9284                                                 # than 0 or 1 so return an error.
9285
9286                                                 kiriwrite_error("invalidvariable");
9287
9288                                         }
9289
9290                                 }
9291
9292                                 # Append the forward slash, clear the current directory name and set
9293                                 # the first directory level value to 0.
9294
9295                                 $variable_data_directory = $variable_data_directory . $variable_data_char;
9296                                 $variable_data_directorycurrent = "";
9297                                 $variable_data_firstlevel = 0;
9298
9299                         } else {
9300
9301                                 # Append the current character to the directory name and to the current
9302                                 # directory name.
9303
9304                                 $variable_data_directory = $variable_data_directory . $variable_data_char;
9305                                 $variable_data_directorycurrent = $variable_data_directorycurrent . $variable_data_char;
9306
9307                         }
9308
9309                         # Increment the seek counter.
9310
9311                         $variable_data_seek++;
9312
9313                 } until ($variable_data_seek eq $variable_data_length);
9314
9315                 return 0;
9316
9317         } elsif ($variable_type eq "datetime"){
9318                 # Check if the date and time setting format is valid.
9319
9320                 if ($variable_data eq ""){
9321
9322                         if ($variable_noerror eq 1){
9323
9324                                 # The no error value is set to 1 so return
9325                                 # a value of 1 (meaning that the date and
9326                                 # time format was blank).
9327
9328                                 return 1;
9329
9330                         } elsif ($variable_noerror eq 0){
9331
9332                                 # The no error value is set to 1 so return
9333                                 # an error.
9334
9335                                 kiriwrite_error("blankdatetimeformat");
9336
9337                         } else {
9338
9339                                 # The no error value is something else other
9340                                 # than 0 or 1, so return an error.
9341
9342                                 kiriwrite_error("invalidvariable");
9343
9344                         }
9345
9346                 }
9347
9348                 my $variable_data_validated = $variable_data;
9349                 $variable_data_validated =~ tr|dDmMyYhms/():[ ]||d;
9350
9351                 if ($variable_data_validated eq ""){
9352
9353                         # The date and time format is valid. So
9354                         # skip this bit.
9355
9356                 } else {
9357
9358                         # The validated data variable is not blank, meaning
9359                         # that it contains something else, so return an error
9360                         # (or a value).
9361
9362                         if ($variable_noerror eq 1){
9363
9364                                 # The no error value is set to 1 so return
9365                                 # an value of 2. (meaning that the date and
9366                                 # time format was invalid).
9367
9368                                 return 2;
9369
9370                         } elsif ($variable_noerror eq 0){
9371
9372                                 # The no error value is set to 0 so return
9373                                 # an error.
9374
9375                                 kiriwrite_error("invaliddatetimeformat");
9376
9377                         } else {
9378
9379                                 # The no error value is something else other
9380                                 # than 0 or 1 so return an error.
9381
9382                                 kiriwrite_error("invalidvariable");
9383
9384                         }
9385
9386                 }
9387
9388                 return 0;
9389
9390         } elsif ($variable_type eq "directory"){
9391                 # Check if the directory only contains letters and numbers and
9392                 # return an error if anything else appears.
9393
9394                 my $variable_data_validated = $variable_data;
9395                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
9396
9397                 if ($variable_data eq ""){
9398
9399                         if ($variable_noerror eq 1){
9400
9401                                 # The no error value is set to 1 so return
9402                                 # a value of 1 (meaning that the directory
9403                                 # name was blank).
9404
9405                                 return 1;
9406
9407                         } elsif ($variable_noerror eq 0){
9408
9409                                 # The no error value is set to 1 so return
9410                                 # an error.
9411
9412                                 kiriwrite_error("blankdirectory");
9413
9414                         } else {
9415
9416                                 # The no error value is something else other
9417                                 # than 0 or 1, so return an error.
9418
9419                                 kiriwrite_error("invalidvariable");
9420
9421                         }
9422
9423                 }
9424
9425                 if ($variable_data_validated eq ""){
9426
9427                         # The validated data variable is blank, meaning that
9428                         # it only contains letters and numbers.
9429
9430                 } else {
9431
9432                         # The validated data variable is not blank, meaning
9433                         # that it contains something else, so return an error
9434                         # (or a value).
9435
9436                         if ($variable_noerror eq 1){
9437
9438                                 # The no error value is set to 1 so return
9439                                 # an value of 2. (meaning that the directory
9440                                 # name is invalid).
9441
9442                                 return 2;
9443
9444                         } elsif ($variable_noerror eq 0){
9445
9446                                 # The no error value is set to 0 so return
9447                                 # an error.
9448
9449                                 kiriwrite_error("invaliddirectory");
9450
9451                         } else {
9452
9453                                 # The no error value is something else other
9454                                 # than 0 or 1 so return an error.
9455
9456                                 kiriwrite_error("invalidvariable");
9457
9458                         }
9459
9460                 }
9461
9462                 return 0;
9463
9464         } elsif ($variable_type eq "language_filename"){
9465
9466                 # The variable type is a language filename type.
9467                 # Check if the language file name is blank and
9468                 # if it is then return an error (or value).
9469
9470                 if ($variable_data eq ""){
9471
9472                         # The language filename is blank so check the
9473                         # no error value and return an error (or value).
9474
9475                         if ($variable_noerror eq 1){
9476
9477                                 # Language filename is blank and the no error value
9478                                 # is set as 1, so return a value of 1 (saying that
9479                                 # the language filename is blank).
9480
9481                                 return 1;
9482
9483                         } elsif ($variable_noerror eq 0) {
9484
9485                                 # Language filename is blank and the no error value
9486                                 # is not set as 1, so return an error.
9487
9488                                 kiriwrite_error("emptylanguagefilename");
9489
9490                         } else {
9491
9492                                 # The noerror value is something else other
9493                                 # than 0 or 1 so return an error.
9494
9495                                 kiriwrite_error("invalidvariable");
9496
9497                         }
9498
9499                 }
9500
9501                 # Set the following variables for later on.
9502
9503                 my $variable_data_length = 0;
9504                 my $variable_data_char = "";
9505                 my $variable_data_seek = 0;
9506
9507                 # Get the length of the language file name.
9508
9509                 $variable_data_length = length($variable_data);
9510
9511                 do {
9512
9513                         # Get a character from the language filename passed to this
9514                         # subroutine and the character the seek counter value is set
9515                         # to.
9516
9517                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
9518
9519                         # Check if the language filename contains a forward slash or a dot,
9520                         # if the selected character is a forward slash then return an error
9521                         # (or value).
9522
9523                         if ($variable_data_char eq "/" || $variable_data_char eq "."){
9524
9525                                 # The language filename contains a forward slash or
9526                                 # a dot so depending on the no error value, return
9527                                 # an error or a value.
9528
9529                                 if ($variable_noerror eq 1){
9530
9531                                         # Language filename contains a forward slash or a dot
9532                                         # and the no error value has been set to 1, so return
9533                                         # an value of 2 (saying that the language file name is
9534                                         # invalid).
9535
9536                                         return 2;
9537
9538                                 } elsif ($variable_noerror eq 0) {
9539
9540                                         # Language filename contains a forward slash and the no
9541                                         # error value has not been set to 1, so return an error.
9542
9543                                         kiriwrite_error("invalidlanguagefilename");
9544
9545                                 } else {
9546
9547                                         # The noerror value is something else other than
9548                                         # 1 or 0 so return an error.
9549
9550                                         kiriwrite_error("invalidvariable");
9551
9552                                 }
9553
9554                         }
9555
9556                         # Increment the seek counter.
9557
9558                         $variable_data_seek++;
9559
9560                 } until ($variable_data_seek eq $variable_data_length);
9561
9562                 return 0;
9563
9564         } elsif ($variable_type eq "pagesetting"){
9565
9566                 # The variable type is a page setting, so check if the page
9567                 # setting has one of the valid options.
9568
9569                 if ($variable_data eq 0 || $variable_data eq 1 || $variable_data eq 2 || $variable_data eq 3){
9570
9571                         # The variable is one of the options above, so continue
9572                         # to the end of this section.
9573
9574                 } else {
9575
9576                         # The variable is not one of the options above, so check
9577                         # and see if a error or a value should be returned.
9578
9579                         if ($variable_noerror eq 1){
9580
9581                                 # The page setting is invalid and the no error
9582                                 # value is set 1, so return a value of 1
9583                                 # (saying that the page setting value is
9584                                 # invalid).
9585
9586                                 return 1;
9587
9588                         } elsif ($variable_noerror eq 0) {
9589
9590                                 # Page setting is invalid and the no error value
9591                                 # is not 1, so return an error.
9592
9593                                 kiriwrite_error("invalidvariable");
9594
9595                         } else {
9596
9597                                 # The no error value is something else other
9598                                 # than 0 or 1 so return an error.
9599
9600                                 kiriwrite_error("invalidvariable");
9601
9602                         }
9603
9604                 }
9605
9606                 return 0;
9607
9608         } elsif ($variable_type eq "page_filename"){
9609
9610                 # The variable type is a page filename type. Check
9611                 # if the data is empty and if it is then return an
9612                 # error (or value).
9613
9614                 if ($variable_data eq ""){
9615
9616                         # The filename is blank so check the no error
9617                         # value and depending on it return an value
9618                         # or an error.
9619
9620                         if ($variable_noerror eq 1){
9621
9622                                 # Page filename is blank and the no error value
9623                                 # is set as 1, so return a value of 1 (saying
9624                                 # the filename is blank).
9625
9626                                 return 1;
9627
9628                         } elsif ($variable_noerror eq 0) {
9629
9630                                 # Page filename is blank and the no error value
9631                                 # is not 1, so return an error.
9632
9633                                 kiriwrite_error("emptypagefilename");
9634
9635                         } else {
9636
9637                                 # The no error value is something else other
9638                                 # than 0 or 1 so return an error.
9639
9640                                 kiriwrite_error("invalidvariable");
9641
9642                         }
9643                 }
9644
9645                 # Set the following variables for later on.
9646
9647                 my $variable_data_length = 0;
9648                 my $variable_data_char = "";
9649                 my $variable_data_validated = "";
9650                 my $variable_data_seek = 0;
9651                 my $variable_data_directory = "";
9652                 my $variable_data_directorycurrent = "";
9653                 my $variable_data_firstlevel = 1;
9654
9655                 # Get the length of the filename.
9656
9657                 $variable_data_length = length($variable_data);
9658
9659                 # Check that only valid characters should be appearing in
9660                 # the filename.
9661
9662                 $variable_data_validated = $variable_data;
9663                 $variable_data_validated =~ tr|a-zA-Z0-9\.\/||d;
9664
9665                 if ($variable_data_validated ne ""){
9666
9667                         # The validated variable is not blank, meaning the
9668                         # variable contains invalid characters, so return
9669                         # an error.
9670
9671                         kiriwrite_error("invalidfilename");
9672
9673                 }
9674
9675                 # Check if the page filename contains the directory command
9676                 # for up a directory level and if it is, return an error
9677                 # or return with a number.
9678
9679                 do {
9680
9681                         # Get a character from the filename passed to this subroutine.
9682
9683                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
9684
9685                         # Check if the current character is the forward slash character.
9686
9687                         if ($variable_data_char eq "/"){
9688
9689                                 # Check if the current directory is blank (and on the first level), or if the
9690                                 # current directory contains two dots or one dot, if it does return an error.
9691
9692                                 if ($variable_data_directorycurrent eq "" && $variable_data_firstlevel eq 1 || $variable_data_directorycurrent eq ".." || $variable_data_directorycurrent eq "."){
9693
9694                                         # Check if the noerror value is set to 1, if it is return an
9695                                         # number, else return an proper error.
9696
9697                                         if ($variable_noerror eq 1){
9698
9699                                                 # Page filename contains invalid characters and
9700                                                 # the no error value is set to 1 so return a
9701                                                 # value of 2 (meaning that the page filename
9702                                                 # is invalid).
9703
9704                                                 return 2;
9705
9706                                         } elsif ($variable_noerror eq 0) {
9707
9708                                                 # Page filename contains invalid characters and
9709                                                 # the no error value is set to 0 so return an
9710                                                 # error.
9711
9712                                                 kiriwrite_error("invalidfilename");
9713
9714                                         } else {
9715
9716                                                 # The no error value is something else other
9717                                                 # than 0 or 1 so return an error.
9718
9719                                                 kiriwrite_error("invalidvariable");
9720
9721                                         }
9722
9723                                 }
9724
9725                                 # Append the forward slash, clear the current directory name and set
9726                                 # the first directory level value to 0.
9727
9728                                 $variable_data_directory = $variable_data_directory . $variable_data_char;
9729                                 $variable_data_directorycurrent = "";
9730                                 $variable_data_firstlevel = 0;
9731
9732                         } else {
9733
9734                                 # Append the current character to the directory name and to the current
9735                                 # directory name.
9736
9737                                 $variable_data_directory = $variable_data_directory . $variable_data_char;
9738                                 $variable_data_directorycurrent = $variable_data_directorycurrent . $variable_data_char;
9739
9740                         }
9741
9742                         # Increment the seek counter.
9743
9744                         $variable_data_seek++;
9745
9746                 } until ($variable_data_seek eq $variable_data_length);
9747
9748                 return 0;
9749
9750         } elsif ($variable_type eq "outputmodule"){
9751
9752                 # The variable type is a output module filename.
9753
9754                 # Check if the variable_data is blank and if it is
9755                 # return an error.
9756
9757                 if ($variable_data eq ""){
9758
9759                         # The output module is blank so check if an error
9760                         # value should be returned or a number should be
9761                         # returned.
9762
9763                 } else {
9764
9765                 }
9766
9767                 my $variable_data_validated = $variable_data;
9768                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
9769
9770                 if ($variable_data_validated eq ""){
9771
9772                 } else {
9773
9774                         kiriwrite_error("outputmoduleinvalid");
9775
9776                 }
9777
9778                 return 0;
9779
9780         } elsif ($variable_type eq "utf8"){
9781
9782                 # The variable type is a UTF8 string.
9783
9784                 # Check if the string is a valid UTF8 string.
9785
9786                 if ($variable_data =~ m/^(
9787                         [\x09\x0A\x0D\x20-\x7E]              # ASCII
9788                         | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
9789                         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
9790                         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
9791                         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
9792                         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
9793                         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
9794                         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
9795                 )*$/x){
9796
9797                         # The UTF-8 string is valid.
9798
9799                 } else {
9800
9801                         # The UTF-8 string is not valid, check if the no error
9802                         # value is set to 1 and return an error if it isn't.
9803
9804                         if ($variable_noerror eq 1){
9805
9806                                 # The no error value has been set to 1, so return
9807                                 # a value of 1 (meaning that the UTF-8 string is
9808                                 # invalid).
9809
9810                                 return 1;
9811
9812                         } elsif ($variable_noerror eq 0) {
9813
9814                                 # The no error value has been set to 0, so return
9815                                 # an error.
9816
9817                                 kiriwrite_error("invalidutf8");
9818
9819                         } else {
9820
9821                                 # The no error value is something else other than 0
9822                                 # or 1, so return an error.
9823
9824                                 kiriwrite_error("invalidoption");
9825
9826                         }
9827
9828                 }
9829
9830                 return 0;
9831
9832         } else {
9833                 # Another type than the valid ones above has been specified so return an error specifying an invalid option.
9834                 kiriwrite_error("invalidoption");
9835         }
9836
9837 }
9838
9839 sub kiriwrite_convert{
9840 #################################################################################
9841 # kiriwrite_convert: Converts certain characters.                               #
9842 #                                                                               #
9843 # Usage;                                                                        #
9844 #                                                                               #
9845 # kiriwrite_convert(data, type);                                                #
9846 #                                                                               #
9847 # data          Specifies the data to be used with                              #
9848 # type          The type of conversion to make (convert from or to kiriwrite    #
9849 #               values.                                                         #
9850 #################################################################################
9851
9852         # Get the data that was passed to the subroutine.
9853         my ($data, $type) = @_;
9854
9855         if ($type eq "kiriwrite"){
9856
9857                 # Convert to into the Kiriwrite format.
9858
9859                 $data =~ s/'/''/g;
9860                 $data =~ s/\b//g;
9861
9862         } elsif ($type eq "normal_display"){
9863
9864                 # Convert into a viewable format.
9865
9866                 $data =~ s/&/&amp;/g;
9867                 $data =~ s/\"/&quot;/g;
9868                 $data =~ s/'/'/g;
9869                 $data =~ s/>/&gt;/g;
9870                 $data =~ s/</&lt;/g;
9871                 $data =~ s/\0//g;
9872                 $data =~ s/\b//g;
9873
9874         } elsif ($type eq "normal_out"){
9875
9876                 # Convert into the original format.
9877
9878                 $data =~ s/\0//g;
9879                 $data =~ s/\b//g;
9880
9881         } elsif ($type eq "date"){
9882
9883                 # Convert the date given into the proper date.
9884
9885                 # Create the following varialbes to be used later.
9886
9887                 my $date;
9888                 my $time;
9889                 my $day;
9890                 my $day_full;
9891                 my $month;
9892                 my $month_check;
9893                 my $month_full;
9894                 my $year;
9895                 my $year_short;
9896                 my $hour;
9897                 my $hour_full;
9898                 my $minute;
9899                 my $minute_full;
9900                 my $second;
9901                 my $second_full;
9902                 my $seek = 0;
9903                 my $timelength;
9904                 my $datelength;
9905                 my $daylength;
9906                 my $secondlength;
9907                 my $startchar = 0;
9908                 my $char;
9909                 my $length;
9910                 my $count = 0;
9911
9912                 # Split the date and time.
9913
9914                 $length = length($data);
9915
9916                 if ($length > 0){
9917
9918                         do {
9919
9920                                 # Get the character and check if it is a space.
9921
9922                                 $char = substr($data, $seek, 1);
9923
9924                                 if ($char eq ' '){
9925
9926                                         # The character is a space, so get the date and time.
9927
9928                                         $date           = substr($data, 0, $seek);
9929                                         $timelength     = $length - $seek - 1;
9930                                         $time           = substr($data, $seek + 1, $timelength);
9931
9932                                 }
9933
9934                                 $seek++;
9935
9936                         } until ($seek eq $length);
9937
9938                         # Get the year, month and date.
9939
9940                         $length = length($date);
9941                         $seek = 0;
9942
9943                         do {
9944
9945                                 # Get the character and check if it is a dash.
9946
9947                                 $char = substr($date, $seek, 1);
9948
9949                                 if ($char eq '-'){
9950
9951                                         # The character is a dash, so get the year, month or day.
9952
9953                                         $datelength = $seek - $startchar;
9954
9955                                         if ($count eq 0){
9956
9957                                                 # Get the year from the date.
9958
9959                                                 $year           = substr($date, 0, $datelength) + 1900;
9960                                                 $startchar      = $seek;
9961                                                 $count = 1;
9962
9963                                                 # Get the last two characters to get the short year
9964                                                 # version.
9965
9966                                                 $year_short     = substr($year, 2, 2);
9967
9968                                         } elsif ($count eq 1){
9969
9970                                                 # Get the month and day from the date.
9971
9972                                                 $month  = substr($date, $startchar + 1, $datelength - 1) + 1;
9973
9974                                                 # Check if the month is less then 10, if it is
9975                                                 # add a zero to the value.
9976
9977                                                 if ($month < 10){
9978
9979                                                         $month_full = '0' . $month;
9980
9981                                                 } else {
9982
9983                                                         $month_full = $month;
9984
9985                                                 }
9986
9987                                                 $startchar      = $seek;
9988                                                 $count = 2;
9989
9990                                                 $daylength      = $length - $seek + 1;
9991                                                 $day            = substr($date, $startchar + 1, $daylength);
9992
9993                                                 # Check if the day is less than 10, if it is
9994                                                 # add a zero to the value.
9995
9996                                                 if ($day < 10){
9997
9998                                                         $day_full       = '0' . $day;
9999
10000                                                 } else {
10001
10002                                                         $day_full       = $day;
10003
10004                                                 }
10005
10006                                         }
10007
10008                                 }
10009
10010                                 $seek++;
10011
10012                         } until ($seek eq $length);
10013
10014                         # Get the length of the time value and reset certain
10015                         # values to 0.
10016
10017                         $length = length($time);
10018                         $seek = 0;
10019                         $count = 0;
10020                         $startchar = 0;
10021
10022                         do {
10023
10024                                 # Get the character and check if it is a colon.
10025
10026                                 $char = substr($time, $seek, 1);
10027
10028                                 if ($char eq ':'){
10029
10030                                         # The character is a colon, so get the hour, minute and day.
10031
10032                                         $timelength = $seek - $startchar;
10033
10034                                         if ($count eq 0){
10035
10036                                                 # Get the hour from the time.
10037
10038                                                 $hour = substr($time, 0, $timelength);
10039                                                 $count = 1;
10040                                                 $startchar = $seek;
10041
10042                                                 # If the hour is less than ten then add a
10043                                                 # zero.
10044
10045                                                 if ($hour < 10){
10046
10047                                                         $hour_full = '0' . $hour;
10048
10049                                                 } else {
10050
10051                                                         $hour_full = $hour;
10052
10053                                                 }
10054
10055                                         } elsif ($count eq 1){
10056
10057                                                 # Get the minute and second from the time.
10058
10059                                                 $minute = substr($time, $startchar + 1, $timelength - 1);
10060                                                 $count = 2;
10061
10062                                                 # If the minute is less than ten then add a
10063                                                 # zero.
10064
10065                                                 if ($minute < 10){
10066
10067                                                         $minute_full = '0' . $minute;
10068
10069                                                 } else {
10070
10071                                                         $minute_full = $minute;
10072
10073                                                 }
10074
10075                                                 $startchar = $seek;
10076
10077                                                 $secondlength = $length - $seek + 1;
10078                                                 $second = substr($time, $startchar + 1, $secondlength);
10079
10080                                                 # If the second is less than ten then add a
10081                                                 # zero.
10082
10083                                                 if ($second < 10){
10084
10085                                                         $second_full = '0' . $second;
10086
10087                                                 } else {
10088
10089                                                         $second_full = $second;
10090
10091                                                 }
10092
10093                                         }
10094
10095                                 }
10096
10097                                 $seek++;
10098
10099                         } until ($seek eq $length);
10100
10101                         # Get the setting for displaying the date and time.
10102
10103                         $data = $kiriwrite_config{"system_datetime"};
10104
10105                         # Process the setting for displaying the date and time
10106                         # using regular expressions
10107
10108                         $data =~ s/DD/$day_full/g;
10109                         $data =~ s/D/$day/g;
10110                         $data =~ s/MM/$month_full/g;
10111                         $data =~ s/M/$month/g;
10112                         $data =~ s/YY/$year/g;
10113                         $data =~ s/Y/$year_short/g;
10114
10115                         $data =~ s/hh/$hour_full/g;
10116                         $data =~ s/h/$hour/g;
10117                         $data =~ s/mm/$minute_full/g;
10118                         $data =~ s/m/$minute/g;
10119                         $data =~ s/ss/$second_full/g;
10120                         $data =~ s/s/$second/g;
10121
10122                 }
10123
10124         } else {
10125                 kiriwrite_error("invalidoption");
10126         }
10127
10128         return $data;
10129
10130 }
10131
10132 sub kiriwrite_output_header{
10133 #################################################################################
10134 # kiriwrite_output_header: Outputs the header to the browser/stdout/console.    #
10135 #                                                                               #
10136 # Usage:                                                                        #
10137 #                                                                               #
10138 # kiriwrite_output_header(mimetype);                                            #
10139 #                                                                               #
10140 # mimetype      Specifies the mime type of the header.                          #
10141 #################################################################################
10142
10143         # Print a header saying that the page expires immediately since the
10144         # date is set in the past.
10145
10146         #print "Expires: Sunday, 01-Jan-06 00:00:00 GMT\n";
10147         #print "Content-Type: text/html; charset=utf-8\n";
10148         #print header();
10149         print header(-Expires=>'Sunday, 01-Jan-06 00:00:00 GMT', -charset=>'utf-8');
10150         return;
10151 }
10152
10153 sub kiriwrite_processfilename{
10154 #################################################################################
10155 # kiriwrite_processfilename: Processes a name and turns it into a filename that #
10156 # can be used by Kiriwrite.                                                     #
10157 #                                                                               #
10158 # Usage:                                                                        #
10159 #                                                                               #
10160 # kiriwrite_processfilename(text);                                              #
10161 #                                                                               #
10162 # text          Specifies the text to be used in the process for creating a new #
10163 #               filename.                                                       #
10164 #################################################################################
10165
10166         # Get the values that have been passed to the subroutine.
10167
10168         my ($process_text) = @_;
10169
10170         # Define some variables that will be used later on.
10171
10172         my $processed_stageone  = "";
10173         my $processed_stagetwo  = "";
10174         my $processed_length    = "";
10175         my $processed_char      = "";
10176         my $processed_seek      = 0;
10177         my $processed_filename  = "";
10178
10179         # Set the first stage value of the processed filename to the
10180         # process filename and then filter it out to only contain
10181         # numbers and letters (no spaces) and then convert the
10182         # capitals to small letters.
10183
10184         $processed_stageone = $process_text;
10185         $processed_stageone =~ tr#a-zA-Z0-9##cd;
10186         $processed_stageone =~ tr/A-Z/a-z/;
10187
10188         # Now set the second stage value of the processed filename
10189         # to the first stage value of the processed filename and
10190         # then limit the filename down to 64 characters.
10191
10192         $processed_stagetwo = $processed_stageone;
10193         $processed_length = length($processed_stagetwo);
10194
10195         # Process the second stage filename into the final
10196         # filename and do so until the seek counter is 64
10197         # or reaches the length of the second stage filename.
10198
10199         do {
10200
10201                 # Get the character that is the seek counter
10202                 # is set at.
10203
10204                 $processed_char = substr($processed_stagetwo, $processed_seek, 1);
10205
10206                 # Append to the final processed filename.
10207
10208                 $processed_filename = $processed_filename . $processed_char;
10209
10210                 # Increment the seek counter.
10211
10212                 $processed_seek++;
10213
10214         } until ($processed_seek eq 64 || $processed_seek eq $processed_length);
10215
10216         return $processed_filename;
10217
10218 }
10219
10220 sub kiriwrite_error{
10221 #################################################################################
10222 # kiriwrite_error: Prints out an error message.                                 #
10223 #                                                                               #
10224 # Usage:                                                                        #
10225 #                                                                               #
10226 # kiriwrite_error(errortype);                                                   #
10227 #                                                                               #
10228 # errortype     Specifies the type of error that occured.                       #
10229 #################################################################################
10230
10231         # Get the error type from the subroutine.
10232
10233         my ($error_type) = @_;
10234
10235         # Load the list of error messages.
10236
10237         my ($kiriwrite_error, %kiriwrite_error);
10238
10239         %kiriwrite_error = (
10240                 # Catch all error message.
10241                 "generic"                               => "An error has occured but not an error that is known to Kiriwrite.",
10242
10243                 # Standard error messages.
10244                 "blankfilename"                         => "The filename specified was blank.",
10245                 "blankvariable"                         => "A blank variable was specified.",
10246                 "fileexists"                            => "A filename specified already exists.",
10247                 "internalerror"                         => "An internal error has occured within Kiriwrite.",
10248                 "invalidoption"                         => "An invalid option was given.",
10249                 "invalidaction"                         => "An invalid action was specified.",
10250                 "invalidfilename"                       => "The filename given contains invalid characters.",
10251                 "invalidmode"                           => "An invalid mode was specified.",
10252                 "invalidutf8"                           => "A UTF-8 string is invalid.",
10253                 "invalidvariable"                       => "An variable with invalid data has been found.",
10254                 "variabletoolong"                       => "A variable given is too long.",
10255
10256                 # Specific error messages.
10257                 "blankcompiletype"                      => "The compile type specified is blank",
10258                 "blankdatabasepageadd"                  => "No database was specified when trying to add a page.",
10259                 "blankdirectory"                        => "The directory name specified was blank.",
10260                 "blankfindfilter"                       => "The find filter was blank.",
10261                 "blankdatetimeformat"                   => "The date and time format given is blank.",
10262                 "databasecategoriestoolong"             => "The database categories list is too long.",
10263                 "databasecopysame"                      => "The database that the pages are being copied to is the same database that the pages are copied from.",
10264                 "datadirectoryinvalidpermissions"       => "The database directory has invalid permission settings.",
10265                 "databasedescriptiontoolong"            => "The database description is too long.",
10266                 "databasefilenameinvalid"               => "The database filename is invalid.",
10267                 "databasefilenametoolong"               => "The database filename is too long.",
10268                 "databasefileinvalid"                   => "The database file is in an invalid format.",
10269                 "databaseinvalidpermissions"            => "The database has invalid permission settings.",
10270                 "databasenameinvalid"                   => "The database name contains invalid characters.",
10271                 "databasenametoolong"                   => "The database name is too long.",
10272                 "databasenameblank"                     => "The database name is blank.",
10273                 "databasemissingfile"                   => "The database file is missing.",
10274                 "databasemovemissingfile"               => "The database that the pages are moving to is missing.",
10275                 "databasemovesame"                      => "The database that the pages are being moved to is the same database that the pages are moving from.",
10276                 "dbdirectoryblank"                      => "The database directory name given was blank.",
10277                 "dbdirectoryinvalid"                    => "The database directory name given was invalid.",
10278                 "filtersdatabasefilenotcreated"         => "The filters database was not created because of the invalid permissions set for directory where Kiriwrite is being run from.",
10279                 "filtersdbinvalidformat"                => "The filters database is an invalid format.",
10280                 "filtersdbpermissions"                  => "The filters database has invalid permission settings.",
10281                 "filtersdbmissing"                      => "The filters database is missing.",
10282                 "filteridblank"                         => "The filter identification number given is blank.",
10283                 "filterdoesnotexist"                    => "The filter with the identification number given does not exist.",
10284                 "filteridinvalid"                       => "The filter identification number given is invalid.",
10285                 "filteridtoolong"                       => "The filter identification number given is too long.",
10286                 "findfiltertoolong"                     => "The find filter given is too long.",
10287                 "filterpriorityinvalid"                 => "The filter priority number given is invalid.",
10288                 "filterpriorityinvalidchars"            => "The filter priority given contains invalid characters.",
10289                 "filterprioritytoolong"                 => "The filter priority given is too long.",
10290                 "invalidcompiletype"                    => "The compile type given is invalid.",
10291                 "invalidpagenumber"                     => "The page number specified is invalid.",
10292                 "nopagesselected"                       => "No pages were selected.",
10293                 "invaliddirectory"                      => "The directory name specified was invalid.",
10294                 "invaliddatetimeformat"                 => "The date and time format given is invalid.",
10295                 "invalidlanguagefilename"               => "An invalid language filename was given.",
10296                 "newcopydatabasedoesnotexist"           => "The database that the selected pages are being copied to does not exist.",
10297                 "newcopydatabasefileinvalidpermissions" => "The database that the selected pages are being copied has invalid permissions set.",
10298                 "newcopydatabasefileinvalid"            => "The database that the selected pages are being copied to is in an invalid format.",
10299                 "newmovedatabasedoesnotexist"           => "The database that the selected pages are moving to does not exist.",
10300                 "newmovedatabasefileinvalidpermissions" => "The database that the selected pages are moving to has invalid permissions set.",
10301                 "newmovedatabasefileinvalid"            => "The database that the selected pages are moving to is in an invalid format.",
10302                 "nodatabasesavailable"                  => "No databases are available for compiling.",
10303                 "nodatabaseselected"                    => "No databases were selected for compiling.",
10304                 "noeditvaluesselected"                  => "No values will be changed on the selected pages as no values for changing were selected.",
10305                 "oldcopydatabasedoesnotexist"           => "The database that the selected pages are being copied to does not exist.",
10306                 "oldcopydatabasefileinvalidpermissions" => "The database that the selected pages are being copied to has invalid permissions set.",
10307                 "oldcopydatabasefileinvalid"            => "The database that the selected pages are being copied to is in an invalid format.",
10308                 "oldmovedatabasedoesnotexist"           => "The database that the selected pages are moving from does not exist.",
10309                 "oldmovedatabasefileinvalidpermissions" => "The database that the selected pages are moving from has invalid permissions set.",
10310                 "oldmovedatabasefileinvalid"            => "The database that the selected pages are moving from is in an invalid format.",
10311                 "outputdirectoryblank"                  => "The output directory name given was blank.",
10312                 "outputdirectoryinvalid"                => "The output directory name given was invalid.",
10313                 "outputdirectorymissing"                => "The output directory is missing",
10314                 "outputdirectoryinvalidpermissions"     => "The output directory has invalid permissions set.",
10315                 "outputmoduleblank"                     => "The output module name given is blank.",
10316                 "outputmoduleinvalid"                   => "The output module name given is invalid.",
10317                 "pagefilenamedoesnotexist"              => "The page with the filename given does not exist.",
10318                 "pagefilenameexists"                    => "The page filename given already exists",
10319                 "pagefilenameinvalid"                   => "The page filename given is invalid.",
10320                 "pagefilenametoolong"                   => "The page filename given is too long.",
10321                 "pagefilenameblank"                     => "The page filename given is blank.",
10322                 "pagetitletoolong"                      => "The page title given is too long.",
10323                 "pagedescriptiontoolong"                => "The page description given is too long.",
10324                 "pagesectiontoolong"                    => "The page section given is too long.",
10325                 "pagedatabasefilenametoolong"           => "The page database filename given is too long.",
10326                 "pagesettingstoolong"                   => "The page settings given is too long.",
10327                 "pagesettingsinvalid"                   => "The page settings given are invalid.",
10328                 "pagetemplatefilenametoolong"           => "The page template filename given was too long.",
10329                 "replacefiltertoolong"                  => "The replace filter given is too long",
10330                 "templatenameblank"                     => "The template name given is blank.",
10331                 "templatefilenameexists"                => "A template with the given filename already exists.",
10332                 "templatefilenameinvalid"               => "The template filename given is invalid.",
10333                 "templatedatabaseinvalidpermissions"    => "The template database has invalid permissions.",
10334                 "templatedatabaseinvalidformat"         => "The template database is in a invalid format.",
10335                 "templatedirectoryblank"                => "The template directory name given was blank.",
10336                 "templatedirectoryinvalid"              => "The template directory name given was invalid.",
10337                 "templatedatabasefilenotcreated"        => "The template database was not created because of the invalid permissions set for the directory where Kiriwrite is being run from.",
10338                 "templatefilenametoolong"               => "The template filename given is too long",
10339                 "templatenametoolong"                   => "The template name given is too long",
10340                 "templatedescriptiontoolong"            => "The template description given is too long",
10341                 "templatedatabasemissing"               => "The template database is missing.",
10342                 "templatedoesnotexist"                  => "The template filename given does not exist in the templates database.",
10343                 "templatefilenameblank"                 => "The template filename given was blank.",
10344         );
10345
10346         # Check if the specified error is blank and if it is
10347         # use the generic error messsage.
10348
10349         if (!$kiriwrite_error{$error_type}){
10350                 $error_type = "generic";
10351         }
10352
10353         my $pagedata = "<div class=\"errorbox\"><font class=\"errorheader\">Error!</font><br /><font class=\"errortext\">" . $kiriwrite_error{$error_type} . "</font></div>";
10354
10355         kiriwrite_output_header;
10356         kiriwrite_output_page("Error!", $pagedata, "none");
10357
10358         exit;
10359
10360 }
10361
10362 sub kiriwrite_get_templates{
10363 #################################################################################
10364 # kiriwrite_get_templates: Get the list of templates available (and valid) from #
10365 # the template directory.                                                       #
10366 #                                                                               #
10367 # Usage:                                                                        #
10368 #                                                                               #
10369 # kiriwrite_get_templates();                                                    #
10370 #################################################################################
10371
10372         # Open the template folder and get the list of database configuration files.
10373
10374         opendir(TEMPLATEDIR, $kiriwrite_config{"directory_data_template"});
10375         my @templatedir = grep /m*\.xml/, readdir(TEMPLATEDIR);
10376         closedir(TEMPLATEDIR);
10377
10378         # Get the actual filename of the template by removing the .xml part from
10379         # the filename.
10380
10381         my $templatedir_filename                = "";
10382         my $templatedir_filename_originallength = "";
10383         my $templatedir_filename_char           = "";
10384         my $templatedir_filename_processed      = "";
10385         my $templatedir_filename_seek           = 0;
10386         my $templatedir_filename_length         = 0;
10387         my $templatedir_filename_finallength    = 0;
10388         my @templatelist_processed;
10389         my $templatedir_processed_filename      = "";
10390         my @templatelist_final;
10391         my $templatelist_final_count            = 0;
10392
10393         foreach $templatedir_filename (@templatedir){
10394
10395                 # Get the length of the original filename.
10396
10397                 $templatedir_filename_length            = length($templatedir_filename);
10398                 $templatedir_filename_finallength       = $templatedir_filename_length - 4;
10399
10400                 # Get the filename minus the last four characters and put the processed
10401                 # filename into the array of processed filenames.
10402
10403                 $templatedir_filename_processed         = substr($templatedir_filename, 0, $templatedir_filename_finallength);
10404
10405                 $templatelist_processed[$templatedir_filename_seek] = $templatedir_filename_processed;
10406
10407                 # Increment the counter.
10408
10409                 $templatedir_filename_seek++;
10410
10411                 # Clear certain variables before using them again.
10412
10413                 $templatedir_filename_processed         = "";
10414                 $templatedir_filename_length            = 0;
10415                 $templatedir_filename_finallength       = 0;
10416
10417         }
10418
10419         # Check that each template really does exist and put each valid
10420         # template into the final list.
10421
10422         foreach $templatedir_processed_filename (@templatelist_processed){
10423
10424                 if (-e $kiriwrite_config{"directory_data_template"} . '/' . $templatedir_processed_filename){
10425
10426                         # The template does exist, so add the template to the list of valid templates.
10427
10428                         $templatelist_final[$templatelist_final_count] = $templatedir_processed_filename;
10429                         $templatelist_final_count++;
10430
10431                 }
10432
10433         }
10434
10435         # Return the list of valid templates.
10436
10437         return @templatelist_final;
10438
10439 }
10440
10441 sub kiriwrite_fileexists{
10442 #################################################################################
10443 # kiriwrite_fileexists: Check if a file exists and returns a value depending on #
10444 # if the file exists or not.                                                    #
10445 #                                                                               #
10446 # Usage:                                                                        #
10447 #                                                                               #
10448 # kiriwrite_fileexists(filename);                                               #
10449 #                                                                               #
10450 # filename      Specifies the file name to check if it exists or not.           #
10451 #################################################################################
10452
10453         # Get the value that was passed to the subroutine.
10454
10455         my ($filename) = @_;
10456
10457         # Check if the filename exists, if it does, return a value of 1, else
10458         # return a value of 0, meaning that the file was not found.
10459
10460         if (-e $filename){
10461
10462                 # Specified file does exist so return a value of 1.
10463
10464                 return 0;
10465
10466         } else {
10467
10468                 # Specified file does not exist so return a value of 0.
10469
10470                 return 1;
10471
10472         }
10473
10474 }
10475
10476 sub kiriwrite_filepermissions{
10477 #################################################################################
10478 # kiriwrite_filepermissions: Check if the file permissions of a file and return #
10479 # either a 1 saying that the permissions are valid or return a 0 saying that    #
10480 # the permissions are invalid.                                                  #
10481 #                                                                               #
10482 # Usage:                                                                        #
10483 #                                                                               #
10484 # kiriwrite_filepermissions(filename, [read], [write], [filemissingskip]);      #
10485 #                                                                               #
10486 # filename              Specifies the filename to check for permissions.        #
10487 # read                  Preform check that the file is readable.                #
10488 # write                 Preform check that the file is writeable.               #
10489 # filemissingskip       Skip the check of seeing if it can read or write if the #
10490 #                       file is missing.                                        #
10491 #################################################################################
10492
10493         # Get the values that was passed to the subroutine.
10494
10495         my ($filename, $readpermission, $writepermission, $ignorechecks) = @_;
10496
10497         # Check to make sure that the read permission and write permission values
10498         # are only 1 character long.
10499
10500         kiriwrite_variablecheck($readpermission, "maxlength", 1, 0);
10501         kiriwrite_variablecheck($writepermission, "maxlength", 1, 0);
10502         kiriwrite_variablecheck($ignorechecks, "maxlength", 1, 0);
10503
10504         my $ignorechecks_result = 0;
10505
10506         # Check if the file should be ignored for read and write checking if
10507         # it doesn't exist.
10508
10509         if ($ignorechecks){
10510
10511                 if (-e $filename){
10512
10513                         # The file exists so the checks are to be done.
10514
10515                         $ignorechecks_result = 0;
10516
10517                 } else {
10518
10519                         # The file does not exist so the checks don't need to
10520                         # be done to prevent false positives.
10521
10522                         $ignorechecks_result = 1;
10523
10524                 }
10525
10526         } else {
10527
10528                 $ignorechecks_result = 0;
10529
10530         }
10531
10532         # Check if the file should be checked to see if it can be read.
10533
10534         if ($readpermission && $ignorechecks_result eq 0){
10535
10536                 # The file should be checked to see if it does contain read permissions
10537                 # and return a 0 if it is invalid.
10538
10539                 if (-r $filename){
10540
10541                         # The file is readable, so do nothing.
10542
10543                 } else {
10544
10545                         # The file is not readable, so return 1.
10546
10547                         return 1;
10548
10549                 }
10550
10551         }
10552
10553         # Check if the file should be checked to see if it can be written.
10554
10555         if ($writepermission && $ignorechecks_result eq 0){
10556
10557                 # The file should be checked to see if it does contain write permissions
10558                 # and return a 0 if it is invalid.
10559
10560                 if (-w $filename){
10561
10562                         # The file is writeable, so do nothing.
10563
10564                 } else {
10565
10566                         # The file is not writeable, so return 1.
10567
10568                         return 1;
10569
10570                 }
10571
10572         }
10573
10574         # No problems have occured, so return 0.
10575
10576         return 0;
10577
10578 }
10579
10580 sub kiriwrite_utf8convert{
10581 #################################################################################
10582 # kiriwrite_utf8convert: Properly converts values into UTF-8 and make sure      #
10583 # that the size of the string is correct when doing input validation.           #
10584 #                                                                               #
10585 # Usage:                                                                        #
10586 #                                                                               #
10587 # utfstring     # The UTF-8 string to convert.                                  #
10588 #################################################################################
10589
10590         # Get the values passed to the subroutine.
10591
10592         my ($utfstring) = @_;
10593
10594         # Load the Encode perl module.
10595
10596         use Encode;
10597
10598         # Convert the string.
10599
10600         my $finalutf8 = Encode::decode_utf8( $utfstring );
10601
10602         return $finalutf8;
10603
10604 }
10605
10606 sub kiriwrite_critical{
10607 #################################################################################
10608 # kiriwrite_critical: Displays a critical error message that cannot be          #
10609 # normally by the kiriwrite_error subroutine.                                   #
10610 #                                                                               #
10611 # Usage:                                                                        #
10612 #                                                                               #
10613 # errortype     Specifies the type of critical error that has occured.          #
10614 #################################################################################
10615
10616         # Get the value that was passed to the subroutine.
10617
10618         my ($error_type) = @_;
10619
10620         # Get the error type from the errortype string.
10621
10622         if ($error_type eq "configfilemissing"){
10623
10624                 # The error is that the Kiriwrite configuration file is missing.
10625                 # Print the header, error message and then end the script.
10626
10627                 print header();
10628                 print "Critical Error: The Kiriwrite configuration file is missing! Running the setup script for Kiriwrite is recommended.";
10629                 exit;
10630
10631         } elsif ($error_type eq "configfileinvalidpermissions") {
10632
10633                 # The error is that the Kiriwrite configuration file has invalid
10634                 # permission settings. Print the header, error messsage and then
10635                 # end the script.
10636
10637                 print header();
10638                 print "Critical Error: The Kiriwrite configuration file contains invalid permission settings! Please set the valid permission settings for the configuration file.";
10639                 exit;
10640
10641         } elsif ($error_type eq "outputsystemmissing") {
10642
10643                 # The error is that the output system module is missing. Print the
10644                 # header, error message and then end the script.
10645
10646                 print header();
10647                 print "Critical Error: The output system module is missing! Running the setup script for Kiriwrite is recommended.";
10648                 exit;
10649
10650         } elsif ($error_type eq "outputsysteminvalidpermissions"){
10651
10652                 # The error is that the output system module has invalid permissions
10653                 # set. Print the header, error message and then end the script.
10654
10655                 print header();
10656                 print "Critical Error: The output system module contains invalid permission settings! Please set the valid permission settings for the output module.";
10657                 exit;
10658
10659         }else {
10660
10661                 # The error type is unspecified, so return a generic error message.
10662
10663                 print header();
10664                 print "Critical Error: An unspecified critical error has occured.";
10665                 exit;
10666
10667         }
10668
10669 }
10670
10671 sub kiriwrite_output_page{
10672 #################################################################################
10673 # kiriwrite_output_page: Outputs the page to the browser/stdout/console.        #
10674 #                                                                               #
10675 # Usage:                                                                        #
10676 #                                                                               #
10677 # kiriwrite_output_page(pagetitle, pagedata, menutype);                         #
10678 #                                                                               #
10679 # pagetitle     Specifies the page title.                                       #
10680 # pagedata      Specifies the page data.                                        #
10681 # menutype      Prints out which menu to use.                                   #
10682 #################################################################################
10683
10684         my ($pagetitle, $pagedata, $menutype) = @_;
10685
10686         # Open the script page template and load it into the scriptpage variable,
10687         # while declaring the variable.
10688
10689         open (SCRIPTPAGE, 'page.html');
10690         my @scriptpage = <SCRIPTPAGE>;
10691         close (SCRIPTPAGE);
10692
10693         # Define the variables required.
10694
10695         my $scriptpageline = "";
10696         my $pageoutput = "";
10697         my $menuoutput = "";
10698
10699         # Print out the main menu for Kiriwrite.
10700
10701         $menuoutput = "<a href=\"kiriwrite.cgi?mode=db\">View Databases</a> | <a href=\"kiriwrite.cgi?mode=page\">View Pages</a> | <a href=\"kiriwrite.cgi?mode=filter\">View Filters</a> | <a href=\"kiriwrite.cgi?mode=template\">View Templates</a> | <a href=\"kiriwrite.cgi?mode=compile\">Compile Pages</a> | <a href=\"kiriwrite.cgi?mode=settings\">View Settings</a>\r\n<br />";
10702
10703         # Check what menu is going to be printed along with the default 'top' menu.
10704
10705         if ($menutype eq "database"){
10706                 # If the menu type is database then print out the database sub-menu.
10707                 $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=db\">Show Databases</a> | <a href=\"kiriwrite.cgi?mode=db&action=new\">Add Database</a>";
10708
10709         } elsif ($menutype eq "pages"){
10710                 # If the menu type is pages then print out the pages sub-menu.
10711
10712                 # First, fetch the database name from the HTTP query string.
10713
10714                 my $query = new CGI;
10715                 my $db_filename = $query->param('database');
10716
10717                 # Check if a value has been placed in the db_filename string.
10718
10719                 if (!$db_filename){
10720
10721                         # As the database filename is blank, don't add an option to add a page.
10722
10723                 } else {
10724
10725                         # A database file has been specified so add an option to add a page to
10726                         # the selected database.
10727
10728                         $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=page&action=add&database=" . $db_filename . "\">Add Page</a>";
10729
10730                 }
10731
10732         } elsif ($menutype eq "filter"){
10733
10734                 # If the menu type is filters then print out the filter sub-menu.
10735                 $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=filter\">Show Filters</a> | <a href=\"kiriwrite.cgi?mode=filter&action=add\">Add Filter</a>";
10736
10737         } elsif ($menutype eq "settings"){
10738
10739                 # If the menu type is options then print out the options sub-menu.
10740                 $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=settings\">Show Settings</a> | <a href=\"kiriwrite.cgi?mode=settings&action=edit\">Edit Settings</a>";
10741
10742         } elsif ($menutype eq "template"){
10743
10744                 # If the menu type is template then print out the template sub-menu.
10745                 $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=template\">Show Templates</a> | <a href=\"kiriwrite.cgi?mode=template&action=add\">Add Template</a>";
10746
10747         } elsif ($menutype eq "compile"){
10748
10749                 # If the menu type is compile then print out the compile sub-menu.
10750                 $menuoutput = $menuoutput . "<a href=\"kiriwrite.cgi?mode=compile&action=all\">Compile All</a> | <a href=\"kiriwrite.cgi?mode=compile&action=clean\">Clean Output Directory</a>";
10751
10752         }
10753
10754         # Find <kiriwrite> tages and replace with the apporiate variables.
10755
10756         foreach $scriptpageline (@scriptpage){
10757
10758                 $scriptpageline =~ s/<kiriwrite:menu>/$menuoutput/g;
10759                 $scriptpageline =~ s/<kiriwrite:pagedata>/$pagedata/g;
10760
10761
10762                 # Check if page title specified is blank, otherwise add a page title
10763                 # to the title.
10764
10765                 if ($pagetitle eq ""){
10766                         $scriptpageline =~ s/<kiriwrite:title>//g;
10767                 } else {
10768                         $scriptpageline =~ s/<kiriwrite:title>/ ($pagetitle)/g;
10769                 }
10770
10771                 # Append processed line to the pageoutput variable.
10772
10773                 $pageoutput = $pageoutput . $scriptpageline;
10774
10775         }
10776
10777         # Print out the page to the browser/console/stdout.
10778
10779         print $pageoutput;
10780
10781         return;
10782
10783 }
10784
10785 sub kiriwrite_output_xml{
10786 #################################################################################
10787 # kiriwrite_output_xml: Outputs several types of data to an XML file            #
10788 #                                                                               #
10789 # Usage:                                                                        #
10790 #                                                                               #
10791 # kiriwrite_output_xml(filename, type, data);                                   #
10792 #                                                                               #
10793 # filename      Specifies the filename of the XML file.                         #
10794 # type          Specifies the type of the XML file to be written.               #
10795 # newsettings   Specifies the new settings for the XML file.                    #
10796 #################################################################################
10797
10798         # Get the variables passed from the subroutine.
10799
10800         my ($xml_filename, $xml_type, @newsettings) = @_;
10801
10802         # Check if filename is blank, if it is then return an error.
10803
10804         if ($xml_filename eq ""){
10805                 # Filename is blank, return an error.
10806                 kiriwrite_error("blankfilename");
10807         }
10808
10809         # Validate the XML filename to make sure nothing supicious is being passed.
10810
10811         kiriwrite_variablecheck($xml_filename, "maxlength", 64, 0);
10812         kiriwrite_variablecheck($xml_filename, "filename", "", 0);
10813
10814         # Check what type of XML data to output.
10815
10816         if ($xml_type eq "config") {
10817
10818                 # The type of XML data to output is a Kiriwrite configuration file.
10819
10820                 # Get the data that has been passed to xml_data from the subroutine and
10821                 # split them into seperate values.
10822
10823                 my ($xml_config_databasedir, $xml_config_outputdir, $xml_config_imagesuri, $xml_config_datetime, $xml_config_systemlanguage, $xml_config_outputsystem) = @newsettings;
10824
10825                 # Create the XML data layout.
10826
10827                 my $xmldata = "<?xml version=\"1.0\"?>\r\n\r\n<kiriwrite-config>\r\n";
10828
10829                 $xmldata = $xmldata . "<!-- This file was automatically generated by Kiriwrite, please feel free to edit to your own needs. -->\r\n";
10830                 $xmldata = $xmldata . "\t<settings>\r\n\t\t<directories>\r\n";
10831
10832                 $xmldata = $xmldata . "\t\t\t<database>" . $xml_config_databasedir . "</database>\r\n";
10833                 $xmldata = $xmldata . "\t\t\t<output>" . $xml_config_outputdir  . "</output>\r\n";
10834                 $xmldata = $xmldata . "\t\t\t<images>" . $xml_config_imagesuri . "</images>\r\n";
10835                 $xmldata = $xmldata . "\t\t</directories>\r\n";
10836
10837                 $xmldata = $xmldata . "\t\t<language>\r\n";
10838                 $xmldata = $xmldata . "\t\t\t<type>" . $xml_config_systemlanguage . "</type>\r\n";
10839                 $xmldata = $xmldata . "\t\t</language>\r\n";
10840
10841                 $xmldata = $xmldata . "\t\t<system>\r\n";
10842                 $xmldata = $xmldata . "\t\t\t<output>" . $xml_config_outputsystem . "</output>\r\n";
10843                 $xmldata = $xmldata . "\t\t\t<datetime>" . $xml_config_datetime . "</datetime>\r\n";
10844                 $xmldata = $xmldata . "\t\t</system>\r\n";
10845
10846                 $xmldata = $xmldata . "\t</settings>\r\n";
10847
10848                 $xmldata = $xmldata . "</kiriwrite-config>";
10849
10850                 # Open the Kiriwrite XML configuration file and write the new settings to the
10851                 # configuration file.
10852
10853                 open(XMLCONFIG, "> kiriwrite.xml");
10854                 print XMLCONFIG $xmldata;
10855                 close(XMLCONFIG);
10856
10857         } else {
10858
10859                 # The type of XML data is something else that is not supported by
10860                 # Kiriwrite, so return an error.
10861
10862                 kiriwrite_error("invalidoption");
10863
10864         }
10865
10866         return;
10867
10868 }
10869
10870 #################################################################################
10871 # End listing the functions needed.                                             #
10872 #################################################################################
10873
10874 #################################################################################
10875 # Begin proper script execution.                                                #
10876 #################################################################################
10877
10878 kiriwrite_settings_load;        # Load the configuration options.
10879
10880 my $query = new CGI;            # Easily fetch variables from the HTTP string.
10881
10882
10883
10884 # Check if a mode has been specified and if a mode has been specified, continue
10885 # and work out what mode has been specified.
10886
10887 if ($query->param('mode')){
10888         my $http_query_mode = $query->param('mode');
10889
10890         if ($http_query_mode eq "db"){
10891
10892                 # If mode is 'db' (database), then check what action is required.
10893
10894                 if ($query->param('action')){
10895                         # An action has been specified, so find out what action has been specified.
10896
10897                         my $http_query_action = $query->param('action');
10898
10899                         if ($http_query_action eq "edit"){
10900                                 # The edit action (which mean edit the settings for the selected database) has been specified,
10901                                 # get the database name and check if the action to edit an database has been confirmed.
10902
10903                                 if ($query->param('database')){
10904                                         # If there is a value in the database variable check if it is a valid database. Otherwise,
10905                                         # return an error.
10906
10907                                         my $http_query_database = $query->param('database');
10908
10909                                         # Check if a value for confirm has been specified, if there is, check if it is the correct
10910                                         # value, otherwise return an error.
10911
10912                                         if ($query->param('confirm')){
10913                                                 # A value for confirm has been specified, find out what value it is. If the value is correct
10914                                                 # then edit the database settings, otherwise return an error.
10915
10916                                                 my $http_query_confirm = $query->param('confirm');
10917
10918                                                 if ($http_query_confirm eq "yes"){
10919                                                         # Value is correct, collect the variables to pass onto the database variable.
10920
10921                                                         # Load the XML::Simple module.
10922
10923                                                         use XML::Simple;
10924                                                         my $xsl = XML::Simple->new();
10925
10926                                                         # Get the variables from the HTTP query.
10927
10928                                                         my $newdatabasename             = $query->param('databasename');
10929                                                         my $newdatabasedescription      = $query->param('databasedescription');
10930                                                         my $newdatabasefilename         = $query->param('databasefilename');
10931                                                         my $databasename                = $query->param('olddatabasename');
10932                                                         my $databasedescription         = $query->param('olddatabasedescription');
10933                                                         my $databaseshortname           = $query->param('database');
10934                                                         my $databasenotes               = $query->param('databasenotes');
10935                                                         my $databasecategories          = $query->param('databasecategories');
10936
10937                                                         # Check the permissions of the database configuration file and return
10938                                                         # an error if the database permissions are invalid.
10939
10940                                                         # Pass the variables to the database editing subroutine.
10941
10942                                                         my $pagedata = kiriwrite_database_edit($databaseshortname, $databasename, $databasedescription, $newdatabasefilename, $newdatabasename, $newdatabasedescription, $databasenotes, $databasecategories, 1);
10943
10944                                                         kiriwrite_output_header;
10945                                                         kiriwrite_output_page("Database Edited", $pagedata, "database");
10946                                                         exit;
10947
10948                                                 } else {
10949                                                         # Value is incorrect, return and error.
10950                                                         kiriwrite_error("invalidvariable");
10951                                                 }
10952
10953                                         }
10954
10955                                         # Display the form for editing an database.
10956                                         my $pagedata = kiriwrite_database_edit($http_query_database);
10957
10958                                         kiriwrite_output_header;
10959                                         kiriwrite_output_page("Edit Database", $pagedata, "database");
10960                                         exit;
10961
10962                                 } else {
10963
10964                                         # If there is no value in the database variable, then return an error.
10965                                         kiriwrite_error("invalidvariable");
10966
10967                                 }
10968
10969                         } elsif ($http_query_action eq "delete"){
10970
10971                                 # Action equested is to delete a database, find out if the user has already confirmed deletion of the database
10972                                 # and if the deletion of the database has been confirmed, delete the database.
10973
10974                                 if ($query->param('confirm')){
10975
10976                                         # User has confirmed to delete a database, pass the parameters to the kiriwrite_database_delete
10977                                         # subroutine.
10978
10979                                         my $database_filename = $query->param('database');
10980                                         my $database_confirm = $query->param('confirm');
10981                                         my $pagedata = kiriwrite_database_delete($database_filename, $database_confirm);
10982
10983                                         kiriwrite_output_header;
10984                                         kiriwrite_output_page("Delete Database", $pagedata, "database");
10985
10986                                         exit;
10987
10988                                 }
10989
10990                                 # User has clicked on the delete link (thus hasn't confirmed the action to delete a database).
10991
10992                                 my $database_filename = $query->param('database');
10993                                 my $pagedata = kiriwrite_database_delete($database_filename);
10994
10995                                 kiriwrite_output_header;
10996                                 kiriwrite_output_page("Delete Database", $pagedata, "database");
10997
10998                                 exit;
10999
11000                         } elsif ($http_query_action eq "new"){
11001
11002                                 # Action requested is to create a new database, find out if the user has already entered the information needed
11003                                 # to create a database and see if the user has confirmed the action, otherwise printout a form for adding a
11004                                 # database.
11005
11006                                 my $http_query_confirm = $query->param('confirm');
11007
11008                                 # Check if the confirm value is correct.
11009
11010                                 if ($http_query_confirm){
11011                                         if ($http_query_confirm eq 1){
11012
11013                                                 # User has confirmed to create a database, pass the parameters to the
11014                                                 # kiriwrite_database_add subroutine.
11015
11016                                                 my $http_query_confirm = $query->param('confirm');
11017
11018                                                 my $database_name               = $query->param('databasename');
11019                                                 my $database_description        = $query->param('databasedescription');
11020                                                 my $database_filename           = $query->param('databasefilename');
11021                                                 my $database_notes              = $query->param('databasenotes');
11022                                                 my $database_categories         = $query->param('databasecategories');
11023
11024                                                 my $pagedata = kiriwrite_database_add($database_filename, $database_name, $database_description, $database_notes, $database_categories, $http_query_confirm);
11025
11026                                                 kiriwrite_output_header;
11027                                                 kiriwrite_output_page("Add Database", $pagedata, "database");
11028                                                 exit;
11029
11030                                         } else {
11031
11032                                                 # The confirm value is something else other than 1 (which it shouldn't be), so
11033                                                 # return an error.
11034
11035                                         }
11036                                 }
11037
11038                                 # User has clicked on the 'Add Database' link.
11039
11040                                 my $pagedata = kiriwrite_database_add;
11041
11042                                 kiriwrite_output_header;
11043                                 kiriwrite_output_page("Add Database", $pagedata, "database");
11044                                 exit;
11045
11046                         } else {
11047                                 # Another option has been specified, so return an error.
11048
11049                                 kiriwrite_error("invalidaction");
11050                         }
11051                 }
11052
11053                 # No action has been specified, do the default action of displaying a list
11054                 # of databases.
11055
11056                 my $pagedata = kiriwrite_database_list;
11057
11058                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11059                 kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
11060                 exit;                                   # End the script.
11061
11062         } elsif ($http_query_mode eq "page"){
11063
11064                 # If mode is 'page', then check what action is required.
11065
11066                 if ($query->param('action')){
11067                         my $http_query_action = $query->param('action');
11068
11069                         # Check if the action requested matches with one of the options below. If it does,
11070                         # go to that section, otherwise return an error.
11071
11072                         if ($http_query_action eq "view"){
11073
11074                                 # The action selected was to view pages from a database,
11075
11076                                 my $database_name       = $query->param('database');
11077                                 my $pagedata            = kiriwrite_page_list($database_name);
11078
11079                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11080                                 kiriwrite_output_page("Viewing Database", $pagedata, "pages");  # Output the page to browser/console/stdout.
11081                                 exit;                   # End the script.
11082
11083                         } elsif ($http_query_action eq "add"){
11084
11085                                 # The action selected was to add a page to the selected database.
11086
11087                                 my $http_query_confirm  = $query->param('confirm');
11088
11089                                 if (!$http_query_confirm){
11090
11091                                         $http_query_confirm = 0;
11092
11093                                 }
11094
11095                                 if ($http_query_confirm eq 1){
11096
11097                                         my $http_query_database         = $query->param('database');
11098                                         my $http_query_filename         = $query->param('pagefilename');
11099                                         my $http_query_name             = $query->param('pagename');
11100                                         my $http_query_description      = $query->param('pagedescription');
11101                                         my $http_query_section          = $query->param('pagesection');
11102                                         my $http_query_template         = $query->param('pagetemplate');
11103                                         my $http_query_settings         = $query->param('pagesettings');
11104                                         my $http_query_content          = $query->param('pagecontent');
11105
11106                                         my $pagedata                    = kiriwrite_page_add($http_query_database, $http_query_filename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
11107
11108                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11109                                         kiriwrite_output_page("Add Page", $pagedata, "pages");  # Output the page to browser/console/stdout.
11110                                         exit;                           # End the script.
11111
11112                                 }
11113
11114                                 my $http_query_database = $query->param('database');
11115                                 my $pagedata            = kiriwrite_page_add($http_query_database);
11116
11117                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11118                                 kiriwrite_output_page("Add Page", $pagedata, "pages");  # Output the page to browser/console/stdout.
11119                                 exit;                           # End the script.
11120
11121                         } elsif ($http_query_action eq "edit"){
11122
11123                                 # The action selected was to edit a page from a database.
11124
11125                                 my $http_query_confirm = $query->param('confirm');
11126
11127                                 if (!$http_query_confirm){
11128
11129                                         $http_query_confirm = 0;
11130
11131                                 }
11132
11133                                 if ($http_query_confirm eq 1){
11134
11135                                         # Get the needed values from the HTTP query.
11136
11137                                         my $http_query_database         = $query->param('database');
11138                                         my $http_query_filename         = $query->param('page');
11139                                         my $http_query_newfilename      = $query->param('pagefilename');
11140                                         my $http_query_name             = $query->param('pagename');
11141                                         my $http_query_description      = $query->param('pagedescription');
11142                                         my $http_query_section          = $query->param('pagesection');
11143                                         my $http_query_template         = $query->param('pagetemplate');
11144                                         my $http_query_settings         = $query->param('pagesettings');
11145                                         my $http_query_content          = $query->param('pagecontent');
11146
11147                                         # Pass the values to the editing pages subroutine.
11148
11149                                         my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename, $http_query_newfilename, $http_query_name, $http_query_description, $http_query_section, $http_query_template, $http_query_settings, $http_query_content, $http_query_confirm);
11150
11151                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11152                                         kiriwrite_output_page("Edit Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
11153                                         exit;                           # End the script.
11154
11155                                 }
11156
11157                                 # Get the needed values from the HTTP query.
11158
11159                                 my $http_query_database = $query->param('database');
11160                                 my $http_query_filename = $query->param('page');
11161
11162                                 # Pass the values to the editing pages subroutine.
11163
11164                                 my $pagedata = kiriwrite_page_edit($http_query_database, $http_query_filename);
11165
11166                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11167                                 kiriwrite_output_page("Edit Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
11168                                 exit;                           # End the script.
11169
11170
11171                         } elsif ($http_query_action eq "delete"){
11172
11173                                 # The action selected was to delete a page from a database.
11174
11175                                 my $http_query_database = $query->param('database');
11176                                 my $http_query_page     = $query->param('page');
11177                                 my $http_query_confirm  = $query->param('confirm');
11178
11179                                 my $pagedata = "";
11180                                 my $selectionlist = "";
11181
11182                                 if ($http_query_confirm){
11183
11184                                         # The action has been confirmed, so try to delete the selected page
11185                                         # from the database.
11186
11187                                         $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page, $http_query_confirm);
11188
11189                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11190                                         kiriwrite_output_page("Delete Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
11191                                         exit;                           # End the script.
11192
11193                                 }
11194
11195                                 $pagedata = kiriwrite_page_delete($http_query_database, $http_query_page);
11196
11197                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11198                                 kiriwrite_output_page("Delete Page", $pagedata, "pages"); # Output the page to browser/console/stdout.
11199                                 exit;                           # End the script.
11200
11201
11202                         } elsif ($http_query_action eq "multidelete"){
11203
11204                                 # The action selected was to delete multiple pages from a
11205                                 # database.
11206
11207                                 my $http_query_database = $query->param('database');
11208                                 my $http_query_confirm  = $query->param('confirm');
11209
11210                                 my @filelist;
11211                                 my $pagedata;
11212
11213                                 if ($http_query_confirm){
11214
11215                                         # The action to delete multiple pages from the selected
11216                                         # database has been confirmed.
11217
11218                                         @filelist       = kiriwrite_selectedlist();
11219                                         $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
11220
11221                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11222                                         kiriwrite_output_page("Delete selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11223                                         exit;                           # End the script.
11224
11225                                 }
11226
11227                                 # Get the list of selected pages and pass them to the
11228                                 # multiple page delete subroutine.
11229
11230                                 @filelist       = kiriwrite_selectedlist();
11231                                 $pagedata       = kiriwrite_page_multidelete($http_query_database, $http_query_confirm, @filelist);
11232
11233                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11234                                 kiriwrite_output_page("Delete selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11235                                 exit;                           # End the script.
11236
11237                         } elsif ($http_query_action eq "multimove"){
11238
11239                                 # The action selected was to move multiple pages from a
11240                                 # database.
11241
11242                                 my $http_query_database         = $query->param('database');
11243                                 my $http_query_newdatabase      = $query->param('newdatabase');
11244                                 my $http_query_confirm          = $query->param('confirm');
11245
11246                                 my @filelist;
11247                                 my $pagedata;
11248
11249                                 if ($http_query_confirm){
11250
11251                                         # The action to move multiple pages from the selected
11252                                         # database has been confirmed.
11253
11254                                         @filelist       = kiriwrite_selectedlist();
11255                                         $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
11256
11257                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11258                                         kiriwrite_output_page("Move selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11259                                         exit;                           # End the script.
11260
11261                                 }
11262
11263                                 # Get the list of selected pages and pass them to the
11264                                 # multiple page move subroutine.
11265
11266                                 @filelist       = kiriwrite_selectedlist();
11267                                 $pagedata       = kiriwrite_page_multimove($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
11268
11269                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11270                                 kiriwrite_output_page("Move selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11271                                 exit;                           # End the script.
11272
11273                         } elsif ($http_query_action eq "multicopy"){
11274
11275                                 # The action selected was to copy multiple pages from a
11276                                 # database.
11277
11278                                 my $http_query_database         = $query->param('database');
11279                                 my $http_query_newdatabase      = $query->param('newdatabase');
11280                                 my $http_query_confirm          = $query->param('confirm');
11281
11282                                 my @filelist;
11283                                 my $pagedata;
11284
11285                                 if ($http_query_confirm){
11286
11287                                         # The action to copy multiple pages from the selected
11288                                         # database has been confirmed.
11289
11290                                         @filelist       = kiriwrite_selectedlist();
11291                                         $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
11292
11293                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11294                                         kiriwrite_output_page("Copy selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11295                                         exit;                           # End the script.
11296
11297                                 }
11298
11299                                 # Get the list of selected pages and pass them to the
11300                                 # multiple page copy subroutine.
11301
11302                                 @filelist       = kiriwrite_selectedlist();
11303                                 $pagedata       = kiriwrite_page_multicopy($http_query_database, $http_query_newdatabase, $http_query_confirm, @filelist);
11304
11305                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11306                                 kiriwrite_output_page("Copy selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11307                                 exit;                           # End the script.
11308
11309                         } elsif ($http_query_action eq "multiedit"){
11310
11311                                 # The action selected was to edit multiple pages from a
11312                                 # database.
11313
11314                                 my $http_query_database         = $query->param('database');
11315                                 my $http_query_newsection       = $query->param('newsection');
11316                                 my $http_query_altersection     = $query->param('altersection');
11317                                 my $http_query_newtemplate      = $query->param('newtemplate');
11318                                 my $http_query_altertemplate    = $query->param('altertemplate');
11319                                 my $http_query_newsettings      = $query->param('newsettings');
11320                                 my $http_query_altersettings    = $query->param('altersettings');
11321                                 my $http_query_confirm          = $query->param('confirm');
11322
11323                                 my @filelist;
11324                                 my $pagedata;
11325
11326                                 if (!$http_query_confirm){
11327
11328                                         @filelist       = kiriwrite_selectedlist();
11329                                         $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
11330
11331                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11332                                         kiriwrite_output_page("Edit selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11333                                         exit;
11334
11335                                 }
11336
11337                                 # Get the list of selected pages and pass them to the
11338                                 # multiple page edit subroutine.
11339
11340                                 @filelist       = kiriwrite_selectedlist();
11341                                 $pagedata       = kiriwrite_page_multiedit($http_query_database, $http_query_newsection, $http_query_altersection, $http_query_newtemplate, $http_query_altertemplate, $http_query_newsettings, $http_query_altersettings, $http_query_confirm, @filelist);
11342
11343                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11344                                 kiriwrite_output_page("Edit selected pages", $pagedata, "pages"); # Output the page to browser/console/stdout.
11345                                 exit;                           # End the script.
11346
11347                         } else {
11348                                 kiriwrite_error("invalidaction");
11349                         }
11350
11351                 } else {
11352
11353                         # If there the action option is left blank, then print out a form where the database
11354                         # can be selected to view pages from.
11355
11356                         my $pagedata = kiriwrite_page_list;
11357
11358                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11359                         kiriwrite_output_page("Database Selection", $pagedata, "pages");        # Output the page to browser/console/stdout.
11360                         exit;                           # End the script.
11361
11362                 }
11363
11364                 # No action has been specified, do the default action of listing pages from
11365                 # the first database found in the directory.
11366
11367         } elsif ($http_query_mode eq "filter"){
11368
11369                 # If there's a value for action in the HTTP query, then
11370                 # get that value that is in the HTTP query.
11371
11372                 if ($query->param('action')){
11373
11374                         # There is a value for action in the HTTP query,
11375                         # so get the value from it.
11376
11377                         my $http_query_action = $query->param('action');
11378
11379                         if ($http_query_action eq "add"){
11380
11381                                 # The action the user requested is to add a filter to the
11382                                 # filters database.
11383
11384                                 # Check if there is a value in confirm and if there is
11385                                 # then pass it on to the new find and replace words
11386                                 # to add to the filter database.
11387
11388                                 my $http_query_confirm = $query->param('confirm');
11389
11390                                 if ($http_query_confirm){
11391
11392                                         # There is a value in http_query_confirm, so pass on the
11393                                         # new find and replace words so that they can be added
11394                                         # to the filters database.
11395
11396                                         my $http_query_findwords        = $query->param('findword');
11397                                         my $http_query_replacewords     = $query->param('replaceword');
11398                                         my $http_query_priority         = $query->param('priority');
11399                                         my $http_query_notes            = $query->param('notes');
11400
11401                                         my $pagedata = kiriwrite_filter_add($http_query_findwords, $http_query_replacewords, $http_query_priority, $http_query_notes, $http_query_confirm);
11402
11403                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11404                                         kiriwrite_output_page("Add Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
11405                                         exit;                           # End the script.
11406
11407                                 }
11408
11409                                 my $pagedata = kiriwrite_filter_add();
11410
11411                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11412                                 kiriwrite_output_page("Add Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
11413                                 exit;                           # End the script.
11414
11415                         } elsif ($http_query_action eq "edit"){
11416
11417                                 # The action the user requested is to edit an filter from
11418                                 # the filters database.
11419
11420                                 my $http_query_number = $query->param('filter');
11421                                 my $http_query_confirm = $query->param('confirm');
11422
11423                                 if ($http_query_confirm){
11424
11425                                         # There is a value in http_query_confirm, so pass on the
11426                                         # new find and replace words so that the filters database
11427                                         # can be edited.
11428
11429                                         my $http_query_findwords        = $query->param('filterfind');
11430                                         my $http_query_replacewords     = $query->param('filterreplace');
11431                                         my $http_query_priority         = $query->param('priority');
11432                                         my $http_query_notes            = $query->param('notes');
11433
11434                                         my $pagedata = kiriwrite_filter_edit($http_query_number, $http_query_findwords, $http_query_replacewords, $http_query_priority, $http_query_notes, $http_query_confirm);
11435
11436                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11437                                         kiriwrite_output_page("Edit Filter", $pagedata, "filter");      # Output the page to browser/console/stdout.
11438                                         exit;                           # End the script.
11439
11440                                 }
11441
11442                                 my $pagedata = kiriwrite_filter_edit($http_query_number);
11443
11444                                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11445                                 kiriwrite_output_page("Edit Filter", $pagedata, "filter");      # Output the page to browser/console/stdout.
11446                                 exit;                                   # End the script.
11447
11448                         } elsif ($http_query_action eq "delete"){
11449
11450                                 # The action the user requested is to delete an filter
11451                                 # from the filters database.
11452
11453                                 my $http_query_number = $query->param('filter');
11454                                 my $http_query_confirm = $query->param('confirm');
11455
11456                                 if ($http_query_confirm){
11457
11458                                         my $pagedata = kiriwrite_filter_delete($http_query_number, $http_query_confirm);
11459
11460                                         kiriwrite_output_header;                # Output the header to browser/console/stdout.
11461                                         kiriwrite_output_page("Delete Filter", $pagedata, "filter"); # Output the page to browser/console/stdout.
11462                                         exit;                                   # End the script
11463
11464                                 }
11465
11466                                 my $pagedata = kiriwrite_filter_delete($http_query_number);
11467
11468                                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11469                                 kiriwrite_output_page("Delete Filter", $pagedata, "filter");    # Output the page to browser/console/stdout.
11470                                 exit;                                   # End the script.
11471
11472                         } else {
11473
11474                                 # Another action was requested that was not one of
11475                                 # the ones prcedding this catch all, so return
11476                                 # an error saying that an invalid option was
11477                                 # specified.
11478
11479                                 kiriwrite_error("invalidaction");
11480
11481                         }
11482
11483                 } else {
11484
11485                         my $pagedata = kiriwrite_filter_list();
11486
11487                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11488                         kiriwrite_output_page("View Filters", $pagedata, "filter"); # Output the page to browser/console/stdout.
11489                         exit;                           # End the script.
11490
11491                 }
11492
11493
11494
11495         } elsif ($http_query_mode eq "template"){
11496
11497                 # Check if an action has been specified in the HTTP query.
11498
11499                 if ($query->param('action')){
11500
11501                         # An action has been specified in the HTTP query.
11502
11503                         my $http_query_action = $query->param('action');
11504
11505                         if ($http_query_action eq "delete"){
11506                                 # Get the required parameters from the HTTP query.
11507
11508                                 my $http_query_template = $query->param('template');
11509                                 my $http_query_confirm  = $query->param('confirm');
11510
11511                                 # Check if a value for confirm has been specified (it shouldn't)
11512                                 # be blank.
11513
11514                                 if ($http_query_confirm eq ""){
11515                                         # The confirm parameter of the HTTP query is blank, so
11516                                         # write out a form asking the user to confirm the deletion
11517                                         # of the selected template.
11518
11519                                         my $pagedata = kiriwrite_template_delete($http_query_template);
11520
11521                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11522                                         kiriwrite_output_page("Delete Template", $pagedata, "template");        # Output the page to browser/console/stdout.
11523                                         exit;                           # End the script.
11524
11525                                 } else {
11526
11527                                         my $pagedata = kiriwrite_template_delete($http_query_template, $http_query_confirm);
11528
11529                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11530                                         kiriwrite_output_page("Delete Template", $pagedata, "template");        # Output the page to browser/console/stdout.
11531                                         exit;                           # End the script.
11532
11533                                 }
11534
11535                         } elsif ($http_query_action eq "add") {
11536
11537                                 # Get the variables from the HTTP query in preperation for processing.
11538
11539                                 my $http_query_confirm  = $query->param('confirm');
11540                                 my $http_query_templatelayout   = $query->param('templatelayout');
11541                                 my $http_query_templatename     = $query->param('templatename');
11542                                 my $http_query_templatedescription = $query->param('templatedescription');
11543                                 my $http_query_templatefilename = $query->param('templatefilename');
11544
11545                                 # Check if there is a confirmed value in the http_query_confirm variable.
11546
11547                                 if (!$http_query_confirm){
11548
11549                                         # Since there is no confirm value, print out a form for creating a new
11550                                         # template.
11551
11552                                         my $pagedata = kiriwrite_template_add();
11553
11554                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11555                                         kiriwrite_output_page("Add Template", $pagedata, "template");   # Output the page to browser/console/stdout.
11556                                         exit;                           # End the script.
11557
11558                                 } else {
11559
11560                                         # A value in the http_query_confirm value is specified, so pass the
11561                                         # variables onto the kiriwrite_template_add subroutine.
11562
11563                                         my $pagedata = kiriwrite_template_add($http_query_templatefilename, $http_query_templatename, $http_query_templatedescription, $http_query_templatelayout, $http_query_confirm);
11564
11565                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11566                                         kiriwrite_output_page("Add Template", $pagedata, "template");   # Output the page to browser/console/stdout.
11567                                         exit;                           # End the script.
11568
11569                                 }
11570
11571                         } elsif ($http_query_action eq "edit") {
11572
11573                                 # Get the required parameters from the HTTP query.
11574
11575                                 my $http_query_templatefile     = $query->param('template');
11576                                 my $http_query_confirm          = $query->param('confirm');
11577
11578                                 # Check to see if http_query_confirm has a value of '1' in it and
11579                                 # if it does, edit the template using the settings providied.
11580
11581                                 if (!$http_query_confirm){
11582
11583                                         # Since there is no confirm value, open the template configuration
11584                                         # file and the template file itself then print out the data on to
11585                                         # the form.
11586
11587                                         my $pagedata = kiriwrite_template_edit($http_query_templatefile);
11588                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11589                                         kiriwrite_output_page("Edit Template", $pagedata, "template");  # Output the page to browser/console/stdout.
11590                                         exit;                           # End the script.
11591
11592                                 } elsif ($http_query_confirm eq 1) {
11593
11594                                         # Since there is a confirm value of 1, the user has confirm the
11595                                         # action of editing of a template so get the other variables
11596                                         # that were also sent and pass the variables to the subroutine.
11597
11598                                         my $http_query_newfilename      = $query->param('newfilename');
11599                                         my $http_query_newname          = $query->param('newname');
11600                                         my $http_query_newdescription   = $query->param('newdescription');
11601                                         my $http_query_newlayout        = $query->param('newlayout');
11602
11603                                         my $pagedata = kiriwrite_template_edit($http_query_templatefile, $http_query_newfilename, $http_query_newname, $http_query_newdescription, $http_query_newlayout, $http_query_confirm);
11604                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11605                                         kiriwrite_output_page("Edit Template", $pagedata, "template");  # Output the page to browser/console/stdout.
11606                                         exit;                           # End the script.
11607
11608                                 } else {
11609
11610                                         # Another confirm value is there instead of '0' or '1'. Return
11611                                         # an error saying it is invalid.
11612
11613                                         kiriwrite_error("invalidvariable");
11614
11615                                 }
11616
11617                         } else {
11618
11619                                 # Another action was specified and was not one of the ones above, so
11620                                 # return an error.
11621
11622                                 kiriwrite_error("invalidaction");
11623
11624                         }
11625
11626                 } else {
11627
11628                         # If the action option is left blank, then print out a form where the list
11629                         # of templates are available.
11630
11631                         my $pagedata = kiriwrite_template_list;
11632
11633                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11634                         kiriwrite_output_page("View Templates", $pagedata, "template"); # Output the page to browser/console/stdout.
11635                         exit;                           # End the script.
11636
11637                 }
11638
11639         } elsif ($http_query_mode eq "compile"){
11640
11641                 # The mode selected is to compile pages from databases.
11642
11643                 # If the action option is left blank, then print out a form where the list
11644                 # of databases to compile are available.
11645
11646                 if ($query->param('action')){
11647
11648                         my $http_query_action = $query->param('action');
11649
11650                         if ($http_query_action eq "compile"){
11651
11652                                 # The specified action is to compile the pages, check if the
11653                                 # action to compile the page has been confirmed.
11654
11655                                 my $http_query_confirm  = $query->param('confirm');
11656                                 my $http_query_type     = $query->param('type');
11657
11658                                 # If it is blank, set the confirm value to 0.
11659
11660                                 if (!$http_query_confirm){
11661
11662                                         # The http_query_confirm variable is uninitalised, so place a
11663                                         # '0' (meaning an unconfirmed action).
11664
11665                                         $http_query_confirm = 0;
11666
11667                                 }
11668
11669                                 # If the compile type is blank then return an error.
11670
11671                                 if (!$http_query_type){
11672
11673                                         # Compile type is blank so return an error.
11674
11675                                         kiriwrite_error("blankcompiletype");
11676
11677                                 }
11678
11679                                 if ($http_query_type eq "multiple"){
11680
11681                                         if ($http_query_confirm eq 1){
11682
11683                                                 # The action to compile the pages has been confirmed so
11684                                                 # compile the pages.
11685
11686                                                 my @selectedlist = kiriwrite_selectedlist();
11687                                                 my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
11688
11689                                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11690                                                 kiriwrite_output_page("Compiled Pages", $pagedata, "compile"); # Output the page to browser/console/stdout.
11691                                                 exit;                           # End the script.
11692
11693                                         } else {
11694
11695                                                 # The action to compile the pages has not been confirmed
11696                                                 # so write a form asking the user to confirm the action
11697                                                 # of compiling the pages.
11698
11699                                                 my @selectedlist = kiriwrite_selectedlist();
11700                                                 my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
11701
11702                                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11703                                                 kiriwrite_output_page("Compile mulitple databases", $pagedata, "compile"); # Output the page to browser/console/stdout.
11704                                                 exit;                           # End the script.
11705
11706                                         }
11707
11708                                 } elsif ($http_query_type eq "single"){
11709
11710                                         my $http_query_database = $query->param('database');
11711                                         my @selectedlist;
11712                                         $selectedlist[0] = $http_query_database;
11713                                         my $pagedata = kiriwrite_compile_makepages($http_query_type, $http_query_confirm, @selectedlist);
11714
11715                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11716                                         kiriwrite_output_page("Compile one database", $pagedata, "compile");
11717                                         exit;                           # End the script.
11718
11719                                 } else {
11720
11721                                         kiriwrite_error("invalidcompiletype");
11722
11723                                 }
11724
11725                         } elsif ($http_query_action eq "all"){
11726
11727                                 # The selected action is to compile all of the databases
11728                                 # in the database directory. Check if the action to
11729                                 # compile all of the databases has been confirmed.
11730
11731                                 my $http_query_confirm = $query->param('confirm');
11732
11733                                 if (!$http_query_confirm){
11734
11735                                         # The http_query_confirm variable is uninitalised, so place a
11736                                         # '0' (meaning an unconfirmed action).
11737
11738                                         $http_query_confirm = 0;
11739
11740                                 }
11741
11742                                 if ($http_query_confirm eq 1){
11743
11744                                         # The action to compile all the databases has been confirmed.
11745
11746                                 }
11747
11748                                 my $pagedata = kiriwrite_compile_all();
11749
11750                                 kiriwrite_output_header;                        # Output the header to browser/console/stdout.
11751                                 kiriwrite_output_page("Compile All Databases", $pagedata, "compile");
11752                                 exit;
11753
11754                         } elsif ($http_query_action eq "clean") {
11755
11756                                 # The selected action is to clean the output directory.
11757                                 # Check if the action to clean the output directory
11758                                 # has been confirmed.
11759
11760                                 my $http_query_confirm = $query->param('confirm');
11761
11762                                 if (!$http_query_confirm){
11763
11764                                         # The http_query_confirm variable is uninitalised, so place a
11765                                         # '0' (meaning an unconfirmed action).
11766
11767                                         $http_query_confirm = 0;
11768
11769                                 }
11770
11771                                 if ($http_query_confirm eq 1){
11772
11773                                         # The action to clean the output directory has been confirmed.
11774
11775                                         my $pagedata = kiriwrite_compile_clean($http_query_confirm);
11776
11777                                         kiriwrite_output_header;                # Output the header to browser/console/stdout.
11778                                         kiriwrite_output_page("Clean Output Directory", $pagedata, "compile");  # Output the page to browser/console/stdout.
11779                                         exit;                                   # End the script.
11780
11781                                 }
11782
11783                                 # The action to clean the output directory is not
11784                                 # confirmed, so write a page asking the user
11785                                 # to confirm cleaning the output directory.
11786
11787                                 my $pagedata = kiriwrite_compile_clean();
11788
11789                                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11790                                 kiriwrite_output_page("Clean Output Directory", $pagedata, "compile");  # Output the page to browser/console/stdout.
11791                                 exit;                                   # End the script.
11792
11793                         } else {
11794
11795                                 # The action specified was something else other than those
11796                                 # above, so return an error.
11797
11798                                 kiriwrite_error("invalidaction");
11799
11800                         }
11801                 }
11802
11803                 my $pagedata = kiriwrite_compile_list;
11804
11805                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11806                 kiriwrite_output_page("Compile Pages", $pagedata, "compile");   # Output the page to browser/console/stdout.
11807                 exit;                                   # End the script.
11808
11809         } elsif ($http_query_mode eq "settings"){
11810
11811                 # The mode selected is view (and change settings).
11812
11813                 # If the action value has been left blank, then view the list of
11814                 # current settings.
11815
11816                 if ($query->param('action')){
11817                         my $http_query_action = $query->param('action');
11818
11819                         if ($http_query_action eq "edit"){
11820
11821                                 # The action specified is to edit the settings. Check if the action
11822                                 # to edit the settings has been confirmed.
11823
11824                                 my $http_query_confirm = $query->param('confirm');
11825
11826                                 if (!$http_query_confirm){
11827
11828                                         # The confirm value is blank, so set it to 0.
11829
11830                                         $http_query_confirm = 0;
11831
11832                                 }
11833
11834                                 if ($http_query_confirm eq 1){
11835
11836                                         # The action to edit the settings has been confirmed. Get the
11837                                         # required settings from the HTTP query.
11838
11839                                         my $http_query_database         = $query->param('databasedir');
11840                                         my $http_query_output           = $query->param('outputdir');
11841                                         my $http_query_imagesuri        = $query->param('imagesuripath');
11842                                         my $http_query_datetimeformat   = $query->param('datetime');
11843                                         my $http_query_systemlanguage   = $query->param('language');
11844                                         my $http_query_outputsystem     = $query->param('outputsys');
11845
11846                                         my $pagedata = kiriwrite_settings_edit($http_query_database, $http_query_output, $http_query_imagesuri, $http_query_datetimeformat, $http_query_systemlanguage, $http_query_outputsystem, $http_query_confirm);
11847
11848                                         kiriwrite_output_header;        # Output the header to browser/console/stdout.
11849                                         kiriwrite_output_page("Edit Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
11850                                         exit;                           # End the script.
11851
11852                                 }
11853
11854                                 # The action to edit the settings has not been confirmed.
11855
11856                                 my $pagedata = kiriwrite_settings_edit;
11857
11858                                 kiriwrite_output_header;        # Output the header to browser/console/stdout.
11859                                 kiriwrite_output_page("Edit Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
11860                                 exit;                           # End the script.
11861
11862                         } else {
11863
11864                                 # The action specified was something else other than those
11865                                 # above, so return an error.
11866
11867                                 kiriwrite_error("invalidaction");
11868
11869                         }
11870
11871                 }
11872
11873                 # No action has been specified, so print out the list of settings currently being used.
11874
11875                 my $pagedata = kiriwrite_settings_view;
11876
11877                 kiriwrite_output_header;                # Output the header to browser/console/stdout.
11878                 kiriwrite_output_page("View Settings", $pagedata, "settings");  # Output the page to browser/console/stdout.
11879                 exit;                                   # End the script.
11880
11881         } else {
11882                 # Another mode has been specified than the ones above, so return an error saying that
11883                 # an invalid option was specified.
11884
11885                 kiriwrite_error("invalidmode");
11886         }
11887
11888 } else {
11889
11890         # No mode has been specified, so print the default "first-run" view of the
11891         # database list.
11892
11893         my $pagedata = kiriwrite_database_list;
11894
11895         kiriwrite_output_header;                # Output the header to browser/console/stdout.
11896         kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
11897         exit;                                   # End the script.
11898
11899 }
11900
11901 __END__
11902
11903 =head1 NAME
11904
11905 Kiriwrite
11906
11907 =head1 DESCRIPTION
11908
11909 Web-based webpage compiler.
11910
11911 =head1 AUTHOR
11912
11913 Steve Brokenshire <sbrokenshire@xestia.co.uk>
11914
11915 =head1 USAGE
11916
11917 This perl script is intended to be used on a web server which has CGI with Perl support or with mod_perl support.
11918
11919 =head1 DOCUMENTATION
11920
11921 For more information on how to use Kiriwrite, please see the documentation that was included with Kiriwrite.
11922
11923 - From the Xestia Documentation website: http://documentation.xestia.co.uk and click on the Kiriwrite link on the page.
11924
11925 - From the Documentation directory from the Kiriwrite source packages (.tar/.tar.gz/.tar.bz2).
11926
11927 - In the /usr/share/doc/kiriwrite directory if you installed the distribution-specific packages (and also have access to the server itself).