Personal
/
cops
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Calibre OPDS (and HTML) PHP Server : web-based light alternative to Calibre content server / Calibre2OPDS to serve ebooks (epub, mobi, pdf, ...) http://blog.slucas.fr/en/oss/calibre-opds-php-server
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1119 Commits
1 Branch
5.4MB
Tree: 270c281741
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '270c281741'
${ noResults }
cops/base.php

1312 lines
47KB
Raw Blame History 

  1. <?php

  2. /**

  3.  * COPS (Calibre OPDS PHP Server) class file

  4.  *

  5.  * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)

  6.  * @author     S�bastien Lucas <sebastien@slucas.fr>

  7.  */

  8. 

  9. define ("VERSION", "1.0.0RC2");

  10. define ("DB", "db");

  11. date_default_timezone_set($config['default_timezone']);

  12. 

  13. 

  14. function useServerSideRendering () {

  15.     global $config;

  16.     return preg_match("/" . $config['cops_server_side_render'] . "/", $_SERVER['HTTP_USER_AGENT']);

  17. }

  18. 

  19. function serverSideRender ($data) {

  20.     // Get the templates

  21.     $theme = getCurrentTemplate ();

  22.     $header = file_get_contents('templates/' . $theme . '/header.html');

  23.     $footer = file_get_contents('templates/' . $theme . '/footer.html');

  24.     $main = file_get_contents('templates/' . $theme . '/main.html');

  25.     $bookdetail = file_get_contents('templates/' . $theme . '/bookdetail.html');

  26.     $page = file_get_contents('templates/' . $theme . '/page.html');

  27. 

  28.     // Generate the function for the template

  29.     $template = new doT ();

  30.     $dot = $template->template ($page, array ("bookdetail" => $bookdetail,

  31.                                               "header" => $header,

  32.                                               "footer" => $footer,

  33.                                               "main" => $main));

  34.     // Execute the template

  35.     if (!empty ($data)) {

  36.         return $dot ($data);

  37.     }

  38. 

  39.     return NULL;

  40. }

  41. 

  42. function getQueryString () {

  43.     if ( isset($_SERVER['QUERY_STRING']) ) {

  44.         return $_SERVER['QUERY_STRING'];

  45.     }

  46.     return "";

  47. }

  48. 

  49. function notFound () {

  50.     header($_SERVER["SERVER_PROTOCOL"]." 404 Not Found");

  51.     header("Status: 404 Not Found");

  52. 

  53.     $_SERVER['REDIRECT_STATUS'] = 404;

  54. }

  55. 

  56. function getURLParam ($name, $default = NULL) {

  57.     if (!empty ($_GET) && isset($_GET[$name]) && $_GET[$name] != "") {

  58.         return $_GET[$name];

  59.     }

  60.     return $default;

  61. }

  62. 

  63. function getCurrentOption ($option) {

  64.     global $config;

  65.     if (isset($_COOKIE[$option])) {

  66.         if (isset($config ["cops_" . $option]) && is_array ($config ["cops_" . $option])) {

  67.             return explode (",", $_COOKIE[$option]);

  68.         } else {

  69.             return $_COOKIE[$option];

  70.         }

  71.     }

  72.     if ($option == "style") {

  73.         return "default";

  74.     }

  75. 

  76.     if (isset($config ["cops_" . $option])) {

  77.         return $config ["cops_" . $option];

  78.     }

  79. 

  80.     return "";

  81. }

  82. 

  83. function getCurrentCss () {

  84.     return "templates/" . getCurrentTemplate () . "/styles/style-" . getCurrentOption ("style") . ".css";

  85. }

  86. 

  87. function getCurrentTemplate () {

  88.     return "default";

  89. }

  90. 

  91. function getUrlWithVersion ($url) {

  92.     return $url . "?v=" . VERSION;

  93. }

  94. 

  95. function xml2xhtml($xml) {

  96.     return preg_replace_callback('#<(\w+)([^>]*)\s*/>#s', create_function('$m', '

  97.         $xhtml_tags = array("br", "hr", "input", "frame", "img", "area", "link", "col", "base", "basefont", "param");

  98.         return in_array($m[1], $xhtml_tags) ? "<$m[1]$m[2] />" : "<$m[1]$m[2]></$m[1]>";

  99.     '), $xml);

  100. }

  101. 

  102. function display_xml_error($error)

  103. {

  104.     $return = "";

  105.     $return .= str_repeat('-', $error->column) . "^\n";

  106. 

  107.     switch ($error->level) {

  108.         case LIBXML_ERR_WARNING:

  109.             $return .= "Warning $error->code: ";

  110.             break;

  111.          case LIBXML_ERR_ERROR:

  112.             $return .= "Error $error->code: ";

  113.             break;

  114.         case LIBXML_ERR_FATAL:

  115.             $return .= "Fatal Error $error->code: ";

  116.             break;

  117.     }

  118. 

  119.     $return .= trim($error->message) .

  120.                "\n  Line: $error->line" .

  121.                "\n  Column: $error->column";

  122. 

  123.     if ($error->file) {

  124.         $return .= "\n  File: $error->file";

  125.     }

  126. 

  127.     return "$return\n\n--------------------------------------------\n\n";

  128. }

  129. 

  130. function are_libxml_errors_ok ()

  131. {

  132.     $errors = libxml_get_errors();

  133. 

  134.     foreach ($errors as $error) {

  135.         if ($error->code == 801) return false;

  136.     }

  137.     return true;

  138. }

  139. 

  140. function html2xhtml ($html) {

  141.     $doc = new DOMDocument();

  142.     libxml_use_internal_errors(true);

  143. 

  144.     $doc->loadHTML('<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"></head><body>' .

  145.                         $html  . '</body></html>'); // Load the HTML

  146.     $output = $doc->saveXML($doc->documentElement); // Transform to an Ansi xml stream

  147.     $output = xml2xhtml($output);

  148.     if (preg_match ('#<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"></meta></head><body>(.*)</body></html>#ms', $output, $matches)) {

  149.         $output = $matches [1]; // Remove <html><body>

  150.     }

  151.     /*

  152.     // In case of error with summary, use it to debug

  153.     $errors = libxml_get_errors();

  154. 

  155.     foreach ($errors as $error) {

  156.         $output .= display_xml_error($error);

  157.     }

  158.     */

  159. 

  160.     if (!are_libxml_errors_ok ()) $output = "HTML code not valid.";

  161. 

  162.     libxml_use_internal_errors(false);

  163.     return $output;

  164. }

  165. 

  166. /**

  167.  * This method is a direct copy-paste from

  168.  * http://tmont.com/blargh/2010/1/string-format-in-php

  169.  */

  170. function str_format($format) {

  171.     $args = func_get_args();

  172.     $format = array_shift($args);

  173. 

  174.     preg_match_all('/(?=\{)\{(\d+)\}(?!\})/', $format, $matches, PREG_OFFSET_CAPTURE);

  175.     $offset = 0;

  176.     foreach ($matches[1] as $data) {

  177.         $i = $data[0];

  178.         $format = substr_replace($format, @$args[$i], $offset + $data[1] - 1, 2 + strlen($i));

  179.         $offset += strlen(@$args[$i]) - 2 - strlen($i);

  180.     }

  181. 

  182.     return $format;

  183. }

  184. 

  185. /**

  186.  * This method is based on this page

  187.  * http://www.mind-it.info/2010/02/22/a-simple-approach-to-localization-in-php/

  188.  */

  189. function localize($phrase, $count=-1, $reset=false) {

  190.     if ($count == 0)

  191.         $phrase .= ".none";

  192.     if ($count == 1)

  193.         $phrase .= ".one";

  194.     if ($count > 1)

  195.         $phrase .= ".many";

  196. 

  197.     /* Static keyword is used to ensure the file is loaded only once */

  198.     static $translations = NULL;

  199.     if ($reset) {

  200.         $translations = NULL;

  201.     }

  202.     /* If no instance of $translations has occured load the language file */

  203.     if (is_null($translations)) {

  204.         $lang = "en";

  205.         if (isset($_SERVER['HTTP_ACCEPT_LANGUAGE']))

  206.         {

  207.             $lang = substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2);

  208.         }

  209.         $lang_file_en = NULL;

  210.         $lang_file = dirname(__FILE__). '/lang/Localization_' . $lang . '.json';

  211.         if (!file_exists($lang_file)) {

  212.             $lang_file = dirname(__FILE__). '/lang/' . 'Localization_en.json';

  213.         }

  214.         elseif ($lang != "en") {

  215.             $lang_file_en = dirname(__FILE__). '/lang/' . 'Localization_en.json';

  216.         }

  217.         $lang_file_content = file_get_contents($lang_file);

  218.         /* Load the language file as a JSON object and transform it into an associative array */

  219.         $translations = json_decode($lang_file_content, true);

  220. 

  221.         /* Clean the array of all unfinished translations */

  222.         foreach (array_keys ($translations) as $key) {

  223.             if (preg_match ("/^##TODO##/", $key)) {

  224.                 unset ($translations [$key]);

  225.             }

  226.         }

  227.         if ($lang_file_en)

  228.         {

  229.             $lang_file_content = file_get_contents($lang_file_en);

  230.             $translations_en = json_decode($lang_file_content, true);

  231.             $translations = array_merge ($translations_en, $translations);

  232.         }

  233.     }

  234.     if (array_key_exists ($phrase, $translations)) {

  235.         return $translations[$phrase];

  236.     }

  237.     return $phrase;

  238. }

  239. 

  240. function addURLParameter($urlParams, $paramName, $paramValue) {

  241.     if (empty ($urlParams)) {

  242.         $urlParams = "";

  243.     }

  244.     $start = "";

  245.     if (preg_match ("#^\?(.*)#", $urlParams, $matches)) {

  246.         $start = "?";

  247.         $urlParams = $matches[1];

  248.     }

  249.     $params = array();

  250.     parse_str($urlParams, $params);

  251.     if (empty ($paramValue) && $paramValue != 0) {

  252.         unset ($params[$paramName]);

  253.     } else {

  254.         $params[$paramName] = $paramValue;

  255.     }

  256.     return $start . http_build_query($params);

  257. }

  258. 

  259. function useNormAndUp () {

  260.     global $config;

  261.     return extension_loaded('mbstring') &&

  262.            extension_loaded('intl') &&

  263.            class_exists("Normalizer", $autoload = false) &&

  264.            $config ['cops_normalized_search'] == "1";

  265. }

  266. 

  267. function normalizeUtf8String( $s)

  268. {

  269.     $original_string = $s;

  270. 

  271.     // maps German (umlauts) and other European characters onto two characters before just removing diacritics

  272.     $s    = preg_replace( '@\x{00c4}@u'    , "AE",    $s );    // umlaut Ä => AE

  273.     $s    = preg_replace( '@\x{00d6}@u'    , "OE",    $s );    // umlaut Ö => OE

  274.     $s    = preg_replace( '@\x{00dc}@u'    , "UE",    $s );    // umlaut Ü => UE

  275.     $s    = preg_replace( '@\x{00e4}@u'    , "ae",    $s );    // umlaut ä => ae

  276.     $s    = preg_replace( '@\x{00f6}@u'    , "oe",    $s );    // umlaut ö => oe

  277.     $s    = preg_replace( '@\x{00fc}@u'    , "ue",    $s );    // umlaut ü => ue

  278.     $s    = preg_replace( '@\x{00f1}@u'    , "ny",    $s );    // ñ => ny

  279.     $s    = preg_replace( '@\x{00ff}@u'    , "yu",    $s );    // ÿ => yu

  280. 

  281. 

  282.     // maps special characters (characters with diacritics) on their base-character followed by the diacritical mark

  283.         // exmaple:  Ú => U´,  á => a`

  284.     $s    = Normalizer::normalize( $s, Normalizer::FORM_D );

  285. 

  286. 

  287.     $s    = preg_replace( '@\pM@u'        , "",    $s );    // removes diacritics

  288. 

  289. 

  290.     $s    = preg_replace( '@\x{00df}@u'    , "ss",    $s );    // maps German ß onto ss

  291.     $s    = preg_replace( '@\x{00c6}@u'    , "AE",    $s );    // Æ => AE

  292.     $s    = preg_replace( '@\x{00e6}@u'    , "ae",    $s );    // æ => ae

  293.     $s    = preg_replace( '@\x{0132}@u'    , "IJ",    $s );    // ? => IJ

  294.     $s    = preg_replace( '@\x{0133}@u'    , "ij",    $s );    // ? => ij

  295.     $s    = preg_replace( '@\x{0152}@u'    , "OE",    $s );    // Π=> OE

  296.     $s    = preg_replace( '@\x{0153}@u'    , "oe",    $s );    // œ => oe

  297. 

  298.     $s    = preg_replace( '@\x{00d0}@u'    , "D",    $s );    // Ð => D

  299.     $s    = preg_replace( '@\x{0110}@u'    , "D",    $s );    // Ð => D

  300.     $s    = preg_replace( '@\x{00f0}@u'    , "d",    $s );    // ð => d

  301.     $s    = preg_replace( '@\x{0111}@u'    , "d",    $s );    // d => d

  302.     $s    = preg_replace( '@\x{0126}@u'    , "H",    $s );    // H => H

  303.     $s    = preg_replace( '@\x{0127}@u'    , "h",    $s );    // h => h

  304.     $s    = preg_replace( '@\x{0131}@u'    , "i",    $s );    // i => i

  305.     $s    = preg_replace( '@\x{0138}@u'    , "k",    $s );    // ? => k

  306.     $s    = preg_replace( '@\x{013f}@u'    , "L",    $s );    // ? => L

  307.     $s    = preg_replace( '@\x{0141}@u'    , "L",    $s );    // L => L

  308.     $s    = preg_replace( '@\x{0140}@u'    , "l",    $s );    // ? => l

  309.     $s    = preg_replace( '@\x{0142}@u'    , "l",    $s );    // l => l

  310.     $s    = preg_replace( '@\x{014a}@u'    , "N",    $s );    // ? => N

  311.     $s    = preg_replace( '@\x{0149}@u'    , "n",    $s );    // ? => n

  312.     $s    = preg_replace( '@\x{014b}@u'    , "n",    $s );    // ? => n

  313.     $s    = preg_replace( '@\x{00d8}@u'    , "O",    $s );    // Ø => O

  314.     $s    = preg_replace( '@\x{00f8}@u'    , "o",    $s );    // ø => o

  315.     $s    = preg_replace( '@\x{017f}@u'    , "s",    $s );    // ? => s

  316.     $s    = preg_replace( '@\x{00de}@u'    , "T",    $s );    // Þ => T

  317.     $s    = preg_replace( '@\x{0166}@u'    , "T",    $s );    // T => T

  318.     $s    = preg_replace( '@\x{00fe}@u'    , "t",    $s );    // þ => t

  319.     $s    = preg_replace( '@\x{0167}@u'    , "t",    $s );    // t => t

  320. 

  321.     // remove all non-ASCii characters

  322.     $s    = preg_replace( '@[^\0-\x80]@u'    , "",    $s );

  323. 

  324. 

  325.     // possible errors in UTF8-regular-expressions

  326.     if (empty($s))

  327.         return $original_string;

  328.     else

  329.         return $s;

  330. }

  331. 

  332. function normAndUp ($a) {

  333.     return mb_strtoupper (normalizeUtf8String($a), 'UTF-8');

  334. }

  335. 

  336. class Link

  337. {

  338.     const OPDS_THUMBNAIL_TYPE = "http://opds-spec.org/image/thumbnail";

  339.     const OPDS_IMAGE_TYPE = "http://opds-spec.org/image";

  340.     const OPDS_ACQUISITION_TYPE = "http://opds-spec.org/acquisition";

  341.     const OPDS_NAVIGATION_TYPE = "application/atom+xml;profile=opds-catalog;kind=navigation";

  342.     const OPDS_PAGING_TYPE = "application/atom+xml;profile=opds-catalog;kind=acquisition";

  343. 

  344.     public $href;

  345.     public $type;

  346.     public $rel;

  347.     public $title;

  348.     public $facetGroup;

  349.     public $activeFacet;

  350. 

  351.     public function __construct($phref, $ptype, $prel = NULL, $ptitle = NULL, $pfacetGroup = NULL, $pactiveFacet = FALSE) {

  352.         $this->href = $phref;

  353.         $this->type = $ptype;

  354.         $this->rel = $prel;

  355.         $this->title = $ptitle;

  356.         $this->facetGroup = $pfacetGroup;

  357.         $this->activeFacet = $pactiveFacet;

  358.     }

  359. 

  360.     public function hrefXhtml () {

  361.         return $this->href;

  362.     }

  363. }

  364. 

  365. class LinkNavigation extends Link

  366. {

  367.     public function __construct($phref, $prel = NULL, $ptitle = NULL) {

  368.         parent::__construct ($phref, Link::OPDS_NAVIGATION_TYPE, $prel, $ptitle);

  369.         if (!is_null (GetUrlParam (DB))) $this->href = addURLParameter ($this->href, DB, GetUrlParam (DB));

  370.         if (!preg_match ("#^\?(.*)#", $this->href) && !empty ($this->href)) $this->href = "?" . $this->href;

  371.         if (preg_match ("/(bookdetail|getJSON).php/", $_SERVER["SCRIPT_NAME"])) {

  372.             $this->href = "index.php" . $this->href;

  373.         } else {

  374.             $this->href = $_SERVER["SCRIPT_NAME"] . $this->href;

  375.         }

  376.     }

  377. }

  378. 

  379. class LinkFacet extends Link

  380. {

  381.     public function __construct($phref, $ptitle = NULL, $pfacetGroup = NULL, $pactiveFacet = FALSE) {

  382.         parent::__construct ($phref, Link::OPDS_PAGING_TYPE, "http://opds-spec.org/facet", $ptitle, $pfacetGroup, $pactiveFacet);

  383.         if (!is_null (GetUrlParam (DB))) $this->href = addURLParameter ($this->href, DB, GetUrlParam (DB));

  384.         $this->href = $_SERVER["SCRIPT_NAME"] . $this->href;

  385.     }

  386. }

  387. 

  388. class Entry

  389. {

  390.     public $title;

  391.     public $id;

  392.     public $content;

  393.     public $numberOfElement;

  394.     public $contentType;

  395.     public $linkArray;

  396.     public $localUpdated;

  397.     public $className;

  398.     private static $updated = NULL;

  399. 

  400.     public static $icons = array(

  401.         Author::ALL_AUTHORS_ID       => 'images/author.png',

  402.         Serie::ALL_SERIES_ID         => 'images/serie.png',

  403.         Book::ALL_RECENT_BOOKS_ID    => 'images/recent.png',

  404.         Tag::ALL_TAGS_ID             => 'images/tag.png',

  405.         Language::ALL_LANGUAGES_ID   => 'images/language.png',

  406.         CustomColumn::ALL_CUSTOMS_ID => 'images/tag.png',

  407.         "cops:books$"             => 'images/allbook.png',

  408.         "cops:books:letter"       => 'images/allbook.png',

  409.         Publisher::ALL_PUBLISHERS_ID => 'images/publisher.png'

  410.     );

  411. 

  412.     public function getUpdatedTime () {

  413.         if (!is_null ($this->localUpdated)) {

  414.             return date (DATE_ATOM, $this->localUpdated);

  415.         }

  416.         if (is_null (self::$updated)) {

  417.             self::$updated = time();

  418.         }

  419.         return date (DATE_ATOM, self::$updated);

  420.     }

  421. 

  422.     public function getNavLink () {

  423.         foreach ($this->linkArray as $link) {

  424.             if ($link->type != Link::OPDS_NAVIGATION_TYPE) { continue; }

  425. 

  426.             return $link->hrefXhtml ();

  427.         }

  428.         return "#";

  429.     }

  430. 

  431.     public function __construct($ptitle, $pid, $pcontent, $pcontentType, $plinkArray, $pclass = "", $pcount = 0) {

  432.         global $config;

  433.         $this->title = $ptitle;

  434.         $this->id = $pid;

  435.         $this->content = $pcontent;

  436.         $this->contentType = $pcontentType;

  437.         $this->linkArray = $plinkArray;

  438.         $this->className = $pclass;

  439.         $this->numberOfElement = $pcount;

  440. 

  441.         if ($config['cops_show_icons'] == 1)

  442.         {

  443.             foreach (self::$icons as $reg => $image)

  444.             {

  445.                 if (preg_match ("/" . $reg . "/", $pid)) {

  446.                     array_push ($this->linkArray, new Link (getUrlWithVersion ($image), "image/png", Link::OPDS_THUMBNAIL_TYPE));

  447.                     break;

  448.                 }

  449.             }

  450.         }

  451. 

  452.         if (!is_null (GetUrlParam (DB))) $this->id = str_replace ("cops:", "cops:" . GetUrlParam (DB) . ":", $this->id);

  453.     }

  454. }

  455. 

  456. class EntryBook extends Entry

  457. {

  458.     public $book;

  459. 

  460.     public function __construct($ptitle, $pid, $pcontent, $pcontentType, $plinkArray, $pbook) {

  461.         parent::__construct ($ptitle, $pid, $pcontent, $pcontentType, $plinkArray);

  462.         $this->book = $pbook;

  463.         $this->localUpdated = $pbook->timestamp;

  464.     }

  465. 

  466.     public function getCoverThumbnail () {

  467.         foreach ($this->linkArray as $link) {

  468.             if ($link->rel == Link::OPDS_THUMBNAIL_TYPE)

  469.                 return $link->hrefXhtml ();

  470.         }

  471.         return null;

  472.     }

  473. 

  474.     public function getCover () {

  475.         foreach ($this->linkArray as $link) {

  476.             if ($link->rel == Link::OPDS_IMAGE_TYPE)

  477.                 return $link->hrefXhtml ();

  478.         }

  479.         return null;

  480.     }

  481. }

  482. 

  483. class Page

  484. {

  485.     public $title;

  486.     public $subtitle = "";

  487.     public $authorName = "";

  488.     public $authorUri = "";

  489.     public $authorEmail = "";

  490.     public $idPage;

  491.     public $idGet;

  492.     public $query;

  493.     public $favicon;

  494.     public $n;

  495.     public $book;

  496.     public $totalNumber = -1;

  497.     public $entryArray = array();

  498. 

  499.     public static function getPage ($pageId, $id, $query, $n)

  500.     {

  501.         switch ($pageId) {

  502.             case Base::PAGE_ALL_AUTHORS :

  503.                 return new PageAllAuthors ($id, $query, $n);

  504.             case Base::PAGE_AUTHORS_FIRST_LETTER :

  505.                 return new PageAllAuthorsLetter ($id, $query, $n);

  506.             case Base::PAGE_AUTHOR_DETAIL :

  507.                 return new PageAuthorDetail ($id, $query, $n);

  508.             case Base::PAGE_ALL_TAGS :

  509.                 return new PageAllTags ($id, $query, $n);

  510.             case Base::PAGE_TAG_DETAIL :

  511.                 return new PageTagDetail ($id, $query, $n);

  512.             case Base::PAGE_ALL_LANGUAGES :

  513.                 return new PageAllLanguages ($id, $query, $n);

  514.             case Base::PAGE_LANGUAGE_DETAIL :

  515.                 return new PageLanguageDetail ($id, $query, $n);

  516.             case Base::PAGE_ALL_CUSTOMS :

  517.                 return new PageAllCustoms ($id, $query, $n);

  518.             case Base::PAGE_CUSTOM_DETAIL :

  519.                 return new PageCustomDetail ($id, $query, $n);

  520.             case Base::PAGE_ALL_RATINGS :

  521.                 return new PageAllRating ($id, $query, $n);

  522.             case Base::PAGE_RATING_DETAIL :

  523.                 return new PageRatingDetail ($id, $query, $n);

  524.             case Base::PAGE_ALL_SERIES :

  525.                 return new PageAllSeries ($id, $query, $n);

  526.             case Base::PAGE_ALL_BOOKS :

  527.                 return new PageAllBooks ($id, $query, $n);

  528.             case Base::PAGE_ALL_BOOKS_LETTER:

  529.                 return new PageAllBooksLetter ($id, $query, $n);

  530.             case Base::PAGE_ALL_RECENT_BOOKS :

  531.                 return new PageRecentBooks ($id, $query, $n);

  532.             case Base::PAGE_SERIE_DETAIL :

  533.                 return new PageSerieDetail ($id, $query, $n);

  534.             case Base::PAGE_OPENSEARCH_QUERY :

  535.                 return new PageQueryResult ($id, $query, $n);

  536.             case Base::PAGE_BOOK_DETAIL :

  537.                 return new PageBookDetail ($id, $query, $n);

  538.             case Base::PAGE_ALL_PUBLISHERS:

  539.                 return new PageAllPublishers ($id, $query, $n);

  540.             case Base::PAGE_PUBLISHER_DETAIL :

  541.                 return new PagePublisherDetail ($id, $query, $n);

  542.             case Base::PAGE_ABOUT :

  543.                 return new PageAbout ($id, $query, $n);

  544.             case Base::PAGE_CUSTOMIZE :

  545.                 return new PageCustomize ($id, $query, $n);

  546.             default:

  547.                 $page = new Page ($id, $query, $n);

  548.                 $page->idPage = "cops:catalog";

  549.                 return $page;

  550.         }

  551.     }

  552. 

  553.     public function __construct($pid, $pquery, $pn) {

  554.         global $config;

  555. 

  556.         $this->idGet = $pid;

  557.         $this->query = $pquery;

  558.         $this->n = $pn;

  559.         $this->favicon = $config['cops_icon'];

  560.         $this->authorName = empty($config['cops_author_name']) ? utf8_encode('S�bastien Lucas') : $config['cops_author_name'];

  561.         $this->authorUri = empty($config['cops_author_uri']) ? 'http://blog.slucas.fr' : $config['cops_author_uri'];

  562.         $this->authorEmail = empty($config['cops_author_email']) ? 'sebastien@slucas.fr' : $config['cops_author_email'];

  563.     }

  564. 

  565.     public function InitializeContent ()

  566.     {

  567.         global $config;

  568.         $this->title = $config['cops_title_default'];

  569.         $this->subtitle = $config['cops_subtitle_default'];

  570.         if (Base::noDatabaseSelected ()) {

  571.             $i = 0;

  572.             foreach (Base::getDbNameList () as $key) {

  573.                 $nBooks = Book::getBookCount ($i);

  574.                 array_push ($this->entryArray, new Entry ($key, "cops:{$i}:catalog",

  575.                                         str_format (localize ("bookword", $nBooks), $nBooks), "text",

  576.                                         array ( new LinkNavigation ("?" . DB . "={$i}")), "", $nBooks));

  577.                 $i++;

  578.                 Base::clearDb ();

  579.             }

  580.         } else {

  581.             if (!in_array (PageQueryResult::SCOPE_AUTHOR, getCurrentOption ('ignored_categories'))) {

  582.                 array_push ($this->entryArray, Author::getCount());

  583.             }

  584.             if (!in_array (PageQueryResult::SCOPE_SERIES, getCurrentOption ('ignored_categories'))) {

  585.                 $series = Serie::getCount();

  586.                 if (!is_null ($series)) array_push ($this->entryArray, $series);

  587.             }

  588.             if (!in_array (PageQueryResult::SCOPE_PUBLISHER, getCurrentOption ('ignored_categories'))) {

  589.                 $publisher = Publisher::getCount();

  590.                 if (!is_null ($publisher)) array_push ($this->entryArray, $publisher);

  591.             }

  592.             if (!in_array (PageQueryResult::SCOPE_TAG, getCurrentOption ('ignored_categories'))) {

  593.                 $tags = Tag::getCount();

  594.                 if (!is_null ($tags)) array_push ($this->entryArray, $tags);

  595.             }

  596.             if (!in_array (PageQueryResult::SCOPE_RATING, getCurrentOption ('ignored_categories'))) {

  597.                 $rating = Rating::getCount();

  598.                 if (!is_null ($rating)) array_push ($this->entryArray, $rating);

  599.             }

  600.             if (!in_array ("language", getCurrentOption ('ignored_categories'))) {

  601.                 $languages = Language::getCount();

  602.                 if (!is_null ($languages)) array_push ($this->entryArray, $languages);

  603.             }

  604.             foreach ($config['cops_calibre_custom_column'] as $lookup) {

  605.                 $customId = CustomColumn::getCustomId ($lookup);

  606.                 if (!is_null ($customId)) {

  607.                     array_push ($this->entryArray, CustomColumn::getCount($customId));

  608.                 }

  609.             }

  610.             $this->entryArray = array_merge ($this->entryArray, Book::getCount());

  611. 

  612.             if (Base::isMultipleDatabaseEnabled ()) $this->title =  Base::getDbName ();

  613.         }

  614.     }

  615. 

  616.     public function isPaginated ()

  617.     {

  618.         return (getCurrentOption ("max_item_per_page") != -1 &&

  619.                 $this->totalNumber != -1 &&

  620.                 $this->totalNumber > getCurrentOption ("max_item_per_page"));

  621.     }

  622. 

  623.     public function getNextLink ()

  624.     {

  625.         $currentUrl = preg_replace ("/\&n=.*?$/", "", "?" . getQueryString ());

  626.         if (($this->n) * getCurrentOption ("max_item_per_page") < $this->totalNumber) {

  627.             return new LinkNavigation ($currentUrl . "&n=" . ($this->n + 1), "next", localize ("paging.next.alternate"));

  628.         }

  629.         return NULL;

  630.     }

  631. 

  632.     public function getPrevLink ()

  633.     {

  634.         $currentUrl = preg_replace ("/\&n=.*?$/", "", "?" . getQueryString ());

  635.         if ($this->n > 1) {

  636.             return new LinkNavigation ($currentUrl . "&n=" . ($this->n - 1), "previous", localize ("paging.previous.alternate"));

  637.         }

  638.         return NULL;

  639.     }

  640. 

  641.     public function getMaxPage ()

  642.     {

  643.         return ceil ($this->totalNumber / getCurrentOption ("max_item_per_page"));

  644.     }

  645. 

  646.     public function containsBook ()

  647.     {

  648.         if (count ($this->entryArray) == 0) return false;

  649.         if (get_class ($this->entryArray [0]) == "EntryBook") return true;

  650.         return false;

  651.     }

  652. }

  653. 

  654. class PageAllAuthors extends Page

  655. {

  656.     public function InitializeContent ()

  657.     {

  658.         $this->title = localize("authors.title");

  659.         if (getCurrentOption ("author_split_first_letter") == 1) {

  660.             $this->entryArray = Author::getAllAuthorsByFirstLetter();

  661.         }

  662.         else {

  663.             $this->entryArray = Author::getAllAuthors();

  664.         }

  665.         $this->idPage = Author::ALL_AUTHORS_ID;

  666.     }

  667. }

  668. 

  669. class PageAllAuthorsLetter extends Page

  670. {

  671.     public function InitializeContent ()

  672.     {

  673.         $this->idPage = Author::getEntryIdByLetter ($this->idGet);

  674.         $this->entryArray = Author::getAuthorsByStartingLetter ($this->idGet);

  675.         $this->title = str_format (localize ("splitByLetter.letter"), str_format (localize ("authorword", count ($this->entryArray)), count ($this->entryArray)), $this->idGet);

  676.     }

  677. }

  678. 

  679. class PageAuthorDetail extends Page

  680. {

  681.     public function InitializeContent ()

  682.     {

  683.         $author = Author::getAuthorById ($this->idGet);

  684.         $this->idPage = $author->getEntryId ();

  685.         $this->title = $author->name;

  686.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByAuthor ($this->idGet, $this->n);

  687.     }

  688. }

  689. 

  690. class PageAllPublishers extends Page

  691. {

  692.     public function InitializeContent ()

  693.     {

  694.         $this->title = localize("publishers.title");

  695.         $this->entryArray = Publisher::getAllPublishers();

  696.         $this->idPage = Publisher::ALL_PUBLISHERS_ID;

  697.     }

  698. }

  699. 

  700. class PagePublisherDetail extends Page

  701. {

  702.     public function InitializeContent ()

  703.     {

  704.         $publisher = Publisher::getPublisherById ($this->idGet);

  705.         $this->title = $publisher->name;

  706.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByPublisher ($this->idGet, $this->n);

  707.         $this->idPage = $publisher->getEntryId ();

  708.     }

  709. }

  710. 

  711. class PageAllTags extends Page

  712. {

  713.     public function InitializeContent ()

  714.     {

  715.         $this->title = localize("tags.title");

  716.         $this->entryArray = Tag::getAllTags();

  717.         $this->idPage = Tag::ALL_TAGS_ID;

  718.     }

  719. }

  720. 

  721. class PageAllLanguages extends Page

  722. {

  723.     public function InitializeContent ()

  724.     {

  725.         $this->title = localize("languages.title");

  726.         $this->entryArray = Language::getAllLanguages();

  727.         $this->idPage = Language::ALL_LANGUAGES_ID;

  728.     }

  729. }

  730. 

  731. class PageCustomDetail extends Page

  732. {

  733.     public function InitializeContent ()

  734.     {

  735.         $customId = getURLParam ("custom", NULL);

  736.         $custom = CustomColumn::getCustomById ($customId, $this->idGet);

  737.         $this->idPage = $custom->getEntryId ();

  738.         $this->title = $custom->name;

  739.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByCustom ($customId, $this->idGet, $this->n);

  740.     }

  741. }

  742. 

  743. class PageAllCustoms extends Page

  744. {

  745.     public function InitializeContent ()

  746.     {

  747.         $customId = getURLParam ("custom", NULL);

  748.         $this->title = CustomColumn::getAllTitle ($customId);

  749.         $this->entryArray = CustomColumn::getAllCustoms($customId);

  750.         $this->idPage = CustomColumn::getAllCustomsId ($customId);

  751.     }

  752. }

  753. 

  754. class PageTagDetail extends Page

  755. {

  756.     public function InitializeContent ()

  757.     {

  758.         $tag = Tag::getTagById ($this->idGet);

  759.         $this->idPage = $tag->getEntryId ();

  760.         $this->title = $tag->name;

  761.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByTag ($this->idGet, $this->n);

  762.     }

  763. }

  764. 

  765. class PageLanguageDetail extends Page

  766. {

  767.     public function InitializeContent ()

  768.     {

  769.         $language = Language::getLanguageById ($this->idGet);

  770.         $this->idPage = $language->getEntryId ();

  771.         $this->title = $language->lang_code;

  772.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByLanguage ($this->idGet, $this->n);

  773.     }

  774. }

  775. 

  776. class PageAllSeries extends Page

  777. {

  778.     public function InitializeContent ()

  779.     {

  780.         $this->title = localize("series.title");

  781.         $this->entryArray = Serie::getAllSeries();

  782.         $this->idPage = Serie::ALL_SERIES_ID;

  783.     }

  784. }

  785. 

  786. class PageSerieDetail extends Page

  787. {

  788.     public function InitializeContent ()

  789.     {

  790.         $serie = Serie::getSerieById ($this->idGet);

  791.         $this->title = $serie->name;

  792.         list ($this->entryArray, $this->totalNumber) = Book::getBooksBySeries ($this->idGet, $this->n);

  793.         $this->idPage = $serie->getEntryId ();

  794.     }

  795. }

  796. 

  797. class PageAllRating extends Page

  798. {

  799.     public function InitializeContent ()

  800.     {

  801.         $this->title = localize("ratings.title");

  802.         $this->entryArray = Rating::getAllRatings();

  803.         $this->idPage = Rating::ALL_RATING_ID;

  804.     }

  805. }

  806. 

  807. class PageRatingDetail extends Page

  808. {

  809.     public function InitializeContent ()

  810.     {

  811.         $rating = Rating::getRatingById ($this->idGet);

  812.         $this->idPage = $rating->getEntryId ();

  813.         $this->title =str_format (localize ("ratingword", $rating->name/2), $rating->name/2);

  814.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByRating ($this->idGet, $this->n);

  815.     }

  816. }

  817. 

  818. class PageAllBooks extends Page

  819. {

  820.     public function InitializeContent ()

  821.     {

  822.         $this->title = localize ("allbooks.title");

  823.         if (getCurrentOption ("titles_split_first_letter") == 1) {

  824.             $this->entryArray = Book::getAllBooks();

  825.         }

  826.         else {

  827.             list ($this->entryArray, $this->totalNumber) = Book::getBooks ($this->n);

  828.         }

  829.         $this->idPage = Book::ALL_BOOKS_ID;

  830.     }

  831. }

  832. 

  833. class PageAllBooksLetter extends Page

  834. {

  835.     public function InitializeContent ()

  836.     {

  837.         list ($this->entryArray, $this->totalNumber) = Book::getBooksByStartingLetter ($this->idGet, $this->n);

  838.         $this->idPage = Book::getEntryIdByLetter ($this->idGet);

  839. 

  840.         $count = $this->totalNumber;

  841.         if ($count == -1)

  842.             $count = count ($this->entryArray);

  843. 

  844.         $this->title = str_format (localize ("splitByLetter.letter"), str_format (localize ("bookword", $count), $count), $this->idGet);

  845.     }

  846. }

  847. 

  848. class PageRecentBooks extends Page

  849. {

  850.     public function InitializeContent ()

  851.     {

  852.         $this->title = localize ("recent.title");

  853.         $this->entryArray = Book::getAllRecentBooks ();

  854.         $this->idPage = Book::ALL_RECENT_BOOKS_ID;

  855.     }

  856. }

  857. 

  858. class PageQueryResult extends Page

  859. {

  860.     const SCOPE_TAG = "tag";

  861.     const SCOPE_RATING = "rating";

  862.     const SCOPE_SERIES = "series";

  863.     const SCOPE_AUTHOR = "author";

  864.     const SCOPE_BOOK = "book";

  865.     const SCOPE_PUBLISHER = "publisher";

  866. 

  867.     private function useTypeahead () {

  868.         return !is_null (getURLParam ("search"));

  869.     }

  870. 

  871.     private function searchByScope ($scope, $limit = FALSE) {

  872.         $n = $this->n;

  873.         $numberPerPage = NULL;

  874.         $queryNormedAndUp = $this->query;

  875.         if (useNormAndUp ()) {

  876.             $queryNormedAndUp = normAndUp ($this->query);

  877.         }

  878.         if ($limit) {

  879.             $n = 1;

  880.             $numberPerPage = 5;

  881.         }

  882.         switch ($scope) {

  883.             case self::SCOPE_BOOK :

  884.                 $array = Book::getBooksByStartingLetter ('%' . $queryNormedAndUp, $n, NULL, $numberPerPage);

  885.                 break;

  886.             case self::SCOPE_AUTHOR :

  887.                 $array = Author::getAuthorsForSearch ('%' . $queryNormedAndUp);

  888.                 break;

  889.             case self::SCOPE_SERIES :

  890.                 $array = Serie::getAllSeriesByQuery ($queryNormedAndUp);

  891.                 break;

  892.             case self::SCOPE_TAG :

  893.                 $array = Tag::getAllTagsByQuery ($queryNormedAndUp, $n, NULL, $numberPerPage);

  894.                 break;

  895.             case self::SCOPE_PUBLISHER :

  896.                 $array = Publisher::getAllPublishersByQuery ($queryNormedAndUp);

  897.                 break;

  898.             default:

  899.                 $array = Book::getBooksByQuery (

  900.                     array ("all" => "%" . $queryNormedAndUp . "%"), $n);

  901.         }

  902. 

  903.         return $array;

  904.     }

  905. 

  906.     public function doSearchByCategory () {

  907.         $database = GetUrlParam (DB);

  908.         $out = array ();

  909.         $pagequery = Base::PAGE_OPENSEARCH_QUERY;

  910.         $dbArray = array ("");

  911.         $d = $database;

  912.         $query = $this->query;

  913.         // Special case when no databases were chosen, we search on all databases

  914.         if (Base::noDatabaseSelected ()) {

  915.             $dbArray = Base::getDbNameList ();

  916.             $d = 0;

  917.         }

  918.         foreach ($dbArray as $key) {

  919.             if (Base::noDatabaseSelected ()) {

  920.                 array_push ($this->entryArray, new Entry ($key, DB . ":query:{$d}",

  921.                                         " ", "text",

  922.                                         array ( new LinkNavigation ("?" . DB . "={$d}")), "tt-header"));

  923.                 Base::getDb ($d);

  924.             }

  925.             foreach (array (PageQueryResult::SCOPE_BOOK,

  926.                             PageQueryResult::SCOPE_AUTHOR,

  927.                             PageQueryResult::SCOPE_SERIES,

  928.                             PageQueryResult::SCOPE_TAG,

  929.                             PageQueryResult::SCOPE_PUBLISHER) as $key) {

  930.                 if (in_array($key, getCurrentOption ('ignored_categories'))) {

  931.                     continue;

  932.                 }

  933.                 $array = $this->searchByScope ($key, TRUE);

  934. 

  935.                 $i = 0;

  936.                 if (count ($array) == 2 && is_array ($array [0])) {

  937.                     $total = $array [1];

  938.                     $array = $array [0];

  939.                 } else {

  940.                     $total = count($array);

  941.                 }

  942.                 if ($total > 0) {

  943.                     // Comment to help the perl i18n script

  944.                     // str_format (localize("bookword", count($array))

  945.                     // str_format (localize("authorword", count($array))

  946.                     // str_format (localize("seriesword", count($array))

  947.                     // str_format (localize("tagword", count($array))

  948.                     // str_format (localize("publisherword", count($array))

  949.                     array_push ($this->entryArray, new Entry (str_format (localize ("search.result.{$key}"), $this->query), DB . ":query:{$d}:{$key}",

  950.                                         str_format (localize("{$key}word", $total), $total), "text",

  951.                                         array ( new LinkNavigation ("?page={$pagequery}&query={$query}&db={$d}&scope={$key}")),

  952.                                         Base::noDatabaseSelected () ? "" : "tt-header"));

  953.                 }

  954.                 if (!Base::noDatabaseSelected () && $this->useTypeahead ()) {

  955.                     foreach ($array as $entry) {

  956.                         array_push ($this->entryArray, $entry);

  957.                         $i++;

  958.                         if ($i > 4) { break; };

  959.                     }

  960.                 }

  961.             }

  962.             $d++;

  963.             if (Base::noDatabaseSelected ()) {

  964.                 Base::clearDb ();

  965.             }

  966.         }

  967.         return $out;

  968.     }

  969. 

  970.     public function InitializeContent ()

  971.     {

  972.         $scope = getURLParam ("scope");

  973.         if (empty ($scope)) {

  974.             $this->title = str_format (localize ("search.result"), $this->query);

  975.         } else {

  976.             // Comment to help the perl i18n script

  977.             // str_format (localize ("search.result.author"), $this->query)

  978.             // str_format (localize ("search.result.tag"), $this->query)

  979.             // str_format (localize ("search.result.series"), $this->query)

  980.             // str_format (localize ("search.result.book"), $this->query)

  981.             // str_format (localize ("search.result.publisher"), $this->query)

  982.             $this->title = str_format (localize ("search.result.{$scope}"), $this->query);

  983.         }

  984. 

  985.         $crit = "%" . $this->query . "%";

  986. 

  987.         // Special case when we are doing a search and no database is selected

  988.         if (Base::noDatabaseSelected () && !$this->useTypeahead ()) {

  989.             $i = 0;

  990.             foreach (Base::getDbNameList () as $key) {

  991.                 Base::clearDb ();

  992.                 list ($array, $totalNumber) = Book::getBooksByQuery (array ("all" => $crit), 1, $i, 1);

  993.                 array_push ($this->entryArray, new Entry ($key, DB . ":query:{$i}",

  994.                                         str_format (localize ("bookword", $totalNumber), $totalNumber), "text",

  995.                                         array ( new LinkNavigation ("?" . DB . "={$i}&page=9&query=" . $this->query))));

  996.                 $i++;

  997.             }

  998.             return;

  999.         }

  1000.         if (empty ($scope)) {

  1001.             $this->doSearchByCategory ();

  1002.             return;

  1003.         }

  1004. 

  1005.         $array = $this->searchByScope ($scope);

  1006.         if (count ($array) == 2 && is_array ($array [0])) {

  1007.             list ($this->entryArray, $this->totalNumber) = $array;

  1008.         } else {

  1009.             $this->entryArray = $array;

  1010.         }

  1011.     }

  1012. }

  1013. 

  1014. class PageBookDetail extends Page

  1015. {

  1016.     public function InitializeContent ()

  1017.     {

  1018.         $this->book = Book::getBookById ($this->idGet);

  1019.         $this->title = $this->book->title;

  1020.     }

  1021. }

  1022. 

  1023. class PageAbout extends Page

  1024. {

  1025.     public function InitializeContent ()

  1026.     {

  1027.         $this->title = localize ("about.title");

  1028.     }

  1029. }

  1030. 

  1031. class PageCustomize extends Page

  1032. {

  1033.     private function isChecked ($key, $testedValue = 1) {

  1034.         $value = getCurrentOption ($key);

  1035.         if (is_array ($value)) {

  1036.             if (in_array ($testedValue, $value)) {

  1037.                 return "checked='checked'";

  1038.             }

  1039.         } else {

  1040.             if ($value == $testedValue) {

  1041.                 return "checked='checked'";

  1042.             }

  1043.         }

  1044.         return "";

  1045.     }

  1046. 

  1047.     private function isSelected ($key, $value) {

  1048.         if (getCurrentOption ($key) == $value) {

  1049.             return "selected='selected'";

  1050.         }

  1051.         return "";

  1052.     }

  1053. 

  1054.     private function getStyleList () {

  1055.         $result = array ();

  1056.         foreach (glob ("templates/" . getCurrentTemplate () . "/styles/style-*.css") as $filename) {

  1057.             if (preg_match ('/styles\/style-(.*?)\.css/', $filename, $m)) {

  1058.                 array_push ($result, $m [1]);

  1059.             }

  1060.         }

  1061.         return $result;

  1062.     }

  1063. 

  1064.     public function InitializeContent ()

  1065.     {

  1066.         $this->title = localize ("customize.title");

  1067.         $this->entryArray = array ();

  1068. 

  1069.         $ignoredBaseArray = array (PageQueryResult::SCOPE_AUTHOR,

  1070.                                    PageQueryResult::SCOPE_TAG,

  1071.                                    PageQueryResult::SCOPE_SERIES,

  1072.                                    PageQueryResult::SCOPE_PUBLISHER,

  1073.                                    PageQueryResult::SCOPE_RATING,

  1074.                                    "language");

  1075. 

  1076.         $content = "";

  1077.         if (!preg_match("/(Kobo|Kindle\/3.0|EBRD1101)/", $_SERVER['HTTP_USER_AGENT'])) {

  1078.             $content .= '<select id="style" onchange="updateCookie (this);">';

  1079.             foreach ($this-> getStyleList () as $filename) {

  1080.                 $content .= "<option value='{$filename}' " . $this->isSelected ("style", $filename) . ">{$filename}</option>";

  1081.             }

  1082.             $content .= '</select>';

  1083.         } else {

  1084.             foreach ($this-> getStyleList () as $filename) {

  1085.                 $content .= "<input type='radio' onchange='updateCookieFromCheckbox (this);' id='style-{$filename}' name='style' value='{$filename}' " . $this->isChecked ("style", $filename) . " /><label for='style-{$filename}'> {$filename} </label>";

  1086.             }

  1087.         }

  1088.         array_push ($this->entryArray, new Entry (localize ("customize.style"), "",

  1089.                                         $content, "text",

  1090.                                         array ()));

  1091.         if (!useServerSideRendering ()) {

  1092.             $content = '<input type="checkbox" onchange="updateCookieFromCheckbox (this);" id="use_fancyapps" ' . $this->isChecked ("use_fancyapps") . ' />';

  1093.             array_push ($this->entryArray, new Entry (localize ("customize.fancybox"), "",

  1094.                                             $content, "text",

  1095.                                             array ()));

  1096.         }

  1097.         $content = '<input type="number" onchange="updateCookie (this);" id="max_item_per_page" value="' . getCurrentOption ("max_item_per_page") . '" min="-1" max="1200" pattern="^[-+]?[0-9]+$" />';

  1098.         array_push ($this->entryArray, new Entry (localize ("customize.paging"), "",

  1099.                                         $content, "text",

  1100.                                         array ()));

  1101.         $content = '<input type="text" onchange="updateCookie (this);" id="email" value="' . getCurrentOption ("email") . '" />';

  1102.         array_push ($this->entryArray, new Entry (localize ("customize.email"), "",

  1103.                                         $content, "text",

  1104.                                         array ()));

  1105.         $content = '<input type="checkbox" onchange="updateCookieFromCheckbox (this);" id="html_tag_filter" ' . $this->isChecked ("html_tag_filter") . ' />';

  1106.         array_push ($this->entryArray, new Entry (localize ("customize.filter"), "",

  1107.                                         $content, "text",

  1108.                                         array ()));

  1109.         $content = "";

  1110.         foreach ($ignoredBaseArray as $key) {

  1111.             $keyPlural = preg_replace ('/(ss)$/', 's', $key . "s");

  1112.             $content .=  '<input type="checkbox" name="ignored_categories[]" onchange="updateCookieFromCheckboxGroup (this);" id="ignored_categories_' . $key . '" ' . $this->isChecked ("ignored_categories", $key) . ' > ' . localize ("{$keyPlural}.title") . '</input> ';

  1113.         }

  1114. 

  1115.         array_push ($this->entryArray, new Entry (localize ("customize.ignored"), "",

  1116.                                         $content, "text",

  1117.                                         array ()));

  1118.     }

  1119. }

  1120. 

  1121. 

  1122. abstract class Base

  1123. {

  1124.     const PAGE_INDEX = "index";

  1125.     const PAGE_ALL_AUTHORS = "1";

  1126.     const PAGE_AUTHORS_FIRST_LETTER = "2";

  1127.     const PAGE_AUTHOR_DETAIL = "3";

  1128.     const PAGE_ALL_BOOKS = "4";

  1129.     const PAGE_ALL_BOOKS_LETTER = "5";

  1130.     const PAGE_ALL_SERIES = "6";

  1131.     const PAGE_SERIE_DETAIL = "7";

  1132.     const PAGE_OPENSEARCH = "8";

  1133.     const PAGE_OPENSEARCH_QUERY = "9";

  1134.     const PAGE_ALL_RECENT_BOOKS = "10";

  1135.     const PAGE_ALL_TAGS = "11";

  1136.     const PAGE_TAG_DETAIL = "12";

  1137.     const PAGE_BOOK_DETAIL = "13";

  1138.     const PAGE_ALL_CUSTOMS = "14";

  1139.     const PAGE_CUSTOM_DETAIL = "15";

  1140.     const PAGE_ABOUT = "16";

  1141.     const PAGE_ALL_LANGUAGES = "17";

  1142.     const PAGE_LANGUAGE_DETAIL = "18";

  1143.     const PAGE_CUSTOMIZE = "19";

  1144.     const PAGE_ALL_PUBLISHERS = "20";

  1145.     const PAGE_PUBLISHER_DETAIL = "21";

  1146.     const PAGE_ALL_RATINGS = "22";

  1147.     const PAGE_RATING_DETAIL = "23";

  1148. 

  1149.     const COMPATIBILITY_XML_ALDIKO = "aldiko";

  1150. 

  1151.     private static $db = NULL;

  1152. 

  1153.     public static function isMultipleDatabaseEnabled () {

  1154.         global $config;

  1155.         return is_array ($config['calibre_directory']);

  1156.     }

  1157. 

  1158.     public static function useAbsolutePath () {

  1159.         global $config;

  1160.         $path = self::getDbDirectory();

  1161.         return preg_match ('/^\//', $path) || // Linux /

  1162.                preg_match ('/^\w\:/', $path); // Windows X:

  1163.     }

  1164. 

  1165.     public static function noDatabaseSelected () {

  1166.         return self::isMultipleDatabaseEnabled () && is_null (GetUrlParam (DB));

  1167.     }

  1168. 

  1169.     public static function getDbList () {

  1170.         global $config;

  1171.         if (self::isMultipleDatabaseEnabled ()) {

  1172.             return $config['calibre_directory'];

  1173.         } else {

  1174.             return array ("" => $config['calibre_directory']);

  1175.         }

  1176.     }

  1177. 

  1178.     public static function getDbNameList () {

  1179.         global $config;

  1180.         if (self::isMultipleDatabaseEnabled ()) {

  1181.             return array_keys ($config['calibre_directory']);

  1182.         } else {

  1183.             return array ("");

  1184.         }

  1185.     }

  1186. 

  1187.     public static function getDbName ($database = NULL) {

  1188.         global $config;

  1189.         if (self::isMultipleDatabaseEnabled ()) {

  1190.             if (is_null ($database)) $database = GetUrlParam (DB, 0);

  1191.             $array = array_keys ($config['calibre_directory']);

  1192.             return  $array[$database];

  1193.         }

  1194.         return "";

  1195.     }

  1196. 

  1197.     public static function getDbDirectory ($database = NULL) {

  1198.         global $config;

  1199.         if (self::isMultipleDatabaseEnabled ()) {

  1200.             if (is_null ($database)) $database = GetUrlParam (DB, 0);

  1201.             $array = array_values ($config['calibre_directory']);

  1202.             return  $array[$database];

  1203.         }

  1204.         return $config['calibre_directory'];

  1205.     }

  1206. 

  1207. 

  1208.     public static function getDbFileName ($database = NULL) {

  1209.         return self::getDbDirectory ($database) .'metadata.db';

  1210.     }

  1211. 

  1212.     private static function error () {

  1213.         if (php_sapi_name() != "cli") {

  1214.             header("location: checkconfig.php?err=1");

  1215.         }

  1216.         throw new Exception('Database not found.');

  1217.     }

  1218. 

  1219.     public static function getDb ($database = NULL) {

  1220.         if (is_null (self::$db)) {

  1221.             try {

  1222.                 if (is_readable (self::getDbFileName ($database))) {

  1223.                     self::$db = new PDO('sqlite:'. self::getDbFileName ($database));

  1224.                     if (useNormAndUp ()) {

  1225.                         self::$db->sqliteCreateFunction ('normAndUp', 'normAndUp', 1);

  1226.                     }

  1227.                 } else {

  1228.                     self::error ();

  1229.                 }

  1230.             } catch (Exception $e) {

  1231.                 self::error ();

  1232.             }

  1233.         }

  1234.         return self::$db;

  1235.     }

  1236. 

  1237.     public static function checkDatabaseAvailability () {

  1238.         if (self::noDatabaseSelected ()) {

  1239.             for ($i = 0; $i < count (self::getDbList ()); $i++) {

  1240.                 self::getDb ($i);

  1241.                 self::clearDb ();

  1242.             }

  1243.         } else {

  1244.             self::getDb ();

  1245.         }

  1246.         return true;

  1247.     }

  1248. 

  1249.     public static function clearDb () {

  1250.         self::$db = NULL;

  1251.     }

  1252. 

  1253.     public static function executeQuerySingle ($query, $database = NULL) {

  1254.         return self::getDb ($database)->query($query)->fetchColumn();

  1255.     }

  1256. 

  1257.     public static function getCountGeneric($table, $id, $pageId, $numberOfString = NULL) {

  1258.         if (!$numberOfString) {

  1259.             $numberOfString = $table . ".alphabetical";

  1260.         }

  1261.         $count = self::executeQuerySingle ('select count(*) from ' . $table);

  1262.         if ($count == 0) return NULL;

  1263.         $entry = new Entry (localize($table . ".title"), $id,

  1264.             str_format (localize($numberOfString, $count), $count), "text",

  1265.             array ( new LinkNavigation ("?page=".$pageId)), "", $count);

  1266.         return $entry;

  1267.     }

  1268. 

  1269.     public static function getEntryArrayWithBookNumber ($query, $columns, $params, $category) {

  1270.         list (, $result) = self::executeQuery ($query, $columns, "", $params, -1);

  1271.         $entryArray = array();

  1272.         while ($post = $result->fetchObject ())

  1273.         {

  1274.             $instance = new $category ($post);

  1275.             array_push ($entryArray, new Entry ($post->sort, $instance->getEntryId (),

  1276.                 str_format (localize("bookword", $post->count), $post->count), "text",

  1277.                 array ( new LinkNavigation ($instance->getUri ())), "", $post->count));

  1278.         }

  1279.         return $entryArray;

  1280.     }

  1281. 

  1282.     public static function executeQuery($query, $columns, $filter, $params, $n, $database = NULL, $numberPerPage = NULL) {

  1283.         $totalResult = -1;

  1284. 

  1285.         if (useNormAndUp ()) {

  1286.             $query = preg_replace("/upper/", "normAndUp", $query);

  1287.             $columns = preg_replace("/upper/", "normAndUp", $columns);

  1288.         }

  1289. 

  1290.         if (is_null ($numberPerPage)) {

  1291.             $numberPerPage = getCurrentOption ("max_item_per_page");

  1292.         }

  1293. 

  1294.         if ($numberPerPage != -1 && $n != -1)

  1295.         {

  1296.             // First check total number of results

  1297.             $result = self::getDb ($database)->prepare (str_format ($query, "count(*)", $filter));

  1298.             $result->execute ($params);

  1299.             $totalResult = $result->fetchColumn ();

  1300. 

  1301.             // Next modify the query and params

  1302.             $query .= " limit ?, ?";

  1303.             array_push ($params, ($n - 1) * $numberPerPage, $numberPerPage);

  1304.         }

  1305. 

  1306.         $result = self::getDb ($database)->prepare(str_format ($query, $columns, $filter));

  1307.         $result->execute ($params);

  1308.         return array ($totalResult, $result);

  1309.     }

  1310. 

  1311. }