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.
509 Commits
1 Branch
5.4MB
Tree: 1dd252e974
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1dd252e974'
${ noResults }
cops/base.php

870 lines
29KB
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", "0.6.1");

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

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

  12.  

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

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

  15.         return $_GET[$name];

  16.     }

  17.     return $default;

  18. }

  19. 

  20. function getCurrentOption ($option) {

  21.     global $config;

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

  23.         return $_COOKIE[$option];

  24.     }

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

  26.         return "default";

  27.     }

  28.     

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

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

  31.     }

  32.     

  33.     return "";

  34. }

  35. 

  36. function getCurrentCss () {

  37.     return "styles/style-" . getCurrentOption ("style") . ".css";

  38. }

  39. 

  40. function getUrlWithVersion ($url) {

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

  42. }

  43. 

  44. function xml2xhtml($xml) {

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

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

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

  48.     '), $xml);

  49. }

  50. 

  51. function display_xml_error($error)

  52. {

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

  54. 

  55.     switch ($error->level) {

  56.         case LIBXML_ERR_WARNING:

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

  58.             break;

  59.          case LIBXML_ERR_ERROR:

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

  61.             break;

  62.         case LIBXML_ERR_FATAL:

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

  64.             break;

  65.     }

  66. 

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

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

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

  70. 

  71.     if ($error->file) {

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

  73.     }

  74. 

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

  76. }

  77. 

  78. function are_libxml_errors_ok ()

  79. {

  80.     $errors = libxml_get_errors();

  81.     

  82.     foreach ($errors as $error) {

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

  84.     }

  85.     return true;

  86. }

  87. 

  88. function html2xhtml ($html) {

  89.     $doc = new DOMDocument();

  90.     libxml_use_internal_errors(true);

  91.     

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

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

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

  95.     $output = xml2xhtml($output);

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

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

  98.     }

  99.     /* 

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

  101.     $errors = libxml_get_errors();

  102. 

  103.     foreach ($errors as $error) {

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

  105.     }

  106.     */

  107.     

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

  109.     

  110.     libxml_use_internal_errors(false);

  111.     return $output;

  112. }

  113. 

  114. /**

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

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

  117.  */

  118. function str_format($format) {

  119.     $args = func_get_args();

  120.     $format = array_shift($args);

  121.     

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

  123.     $offset = 0;

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

  125.         $i = $data[0];

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

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

  128.     }

  129.     

  130.     return $format;

  131. }

  132. 

  133. /**

  134.  * This method is based on this page

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

  136.  */

  137. function localize($phrase, $count=-1) {

  138.     if ($count == 0)

  139.         $phrase .= ".none";

  140.     if ($count == 1)

  141.         $phrase .= ".one";

  142.     if ($count > 1)

  143.         $phrase .= ".many";

  144. 

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

  146.     static $translations = NULL;

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

  148.     if (is_null($translations)) {

  149.         $lang = "en";

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

  151.         {

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

  153.         }

  154.         $lang_file_en = NULL;

  155.         $lang_file = 'lang/Localization_' . $lang . '.json';

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

  157.             $lang_file = 'lang/' . 'Localization_en.json';

  158.         }

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

  160.             $lang_file_en = 'lang/' . 'Localization_en.json';

  161.         }

  162.         $lang_file_content = file_get_contents($lang_file);

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

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

  165.         if ($lang_file_en)

  166.         {

  167.             $lang_file_content = file_get_contents($lang_file_en);

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

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

  170.         }

  171.     }

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

  173.         return $translations[$phrase];

  174.     }

  175.     return $phrase;

  176. }

  177. 

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

  179.     $start = "";

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

  181.         $start = "?";

  182.         $urlParams = $matches[1];

  183.     }

  184.     $params = array();

  185.     parse_str($urlParams, $params);

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

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

  188.     } else {

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

  190.     }

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

  192. }

  193. 

  194. class Link

  195. {

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

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

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

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

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

  201.     

  202.     public $href;

  203.     public $type;

  204.     public $rel;

  205.     public $title;

  206.     public $facetGroup;

  207.     public $activeFacet;

  208.     

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

  210.         $this->href = $phref;

  211.         $this->type = $ptype;

  212.         $this->rel = $prel;

  213.         $this->title = $ptitle;

  214.         $this->facetGroup = $pfacetGroup;

  215.         $this->activeFacet = $pactiveFacet;

  216.     }

  217.     

  218.     public function hrefXhtml () {

  219.         return $this->href;

  220.     }

  221. }

  222. 

  223. class LinkNavigation extends Link

  224. {

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

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

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

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

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

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

  231.         } else {

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

  233.         }

  234.     }

  235. }

  236. 

  237. class LinkFacet extends Link

  238. {

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

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

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

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

  243.     }

  244. }

  245. 

  246. class Entry

  247. {

  248.     public $title;

  249.     public $id;

  250.     public $content;

  251.     public $contentType;

  252.     public $linkArray;

  253.     public $localUpdated;

  254.     private static $updated = NULL;

  255.     

  256.     public static $icons = array(

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

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

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

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

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

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

  263.         "calibre:books$"             => 'images/allbook.png',

  264.         "calibre:books:letter"       => 'images/allbook.png'

  265.     );

  266.     

  267.     public function getUpdatedTime () {

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

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

  270.         }

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

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

  273.         }

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

  275.     }

  276.     

  277.     public function getContentArray () {

  278.         $navlink = "#";

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

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

  281.             

  282.             $navlink = $link->hrefXhtml ();

  283.         }

  284.         return array ( "title" => $this->title, "content" => $this->content, "navlink" => $navlink );

  285.     }

  286.  

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

  288.         global $config;

  289.         $this->title = $ptitle;

  290.         $this->id = $pid;

  291.         $this->content = $pcontent;

  292.         $this->contentType = $pcontentType;

  293.         $this->linkArray = $plinkArray;

  294.         

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

  296.         {

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

  298.             {

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

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

  301.                     break;

  302.                 }

  303.             }

  304.         }

  305.         

  306.         if (!is_null (GetUrlParam (DB))) $this->id = GetUrlParam (DB) . ":" . $this->id;

  307.     }

  308. }

  309. 

  310. class EntryBook extends Entry

  311. {

  312.     public $book;

  313.     

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

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

  316.         $this->book = $pbook;

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

  318.     }

  319.     

  320.     public function getContentArray () {

  321.         $entry = array ( "title" => $this->title);

  322.         $entry ["book"] = $this->book->getContentArray ();

  323.         return $entry;

  324.     }

  325.     

  326.     public function getCoverThumbnail () {

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

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

  329.                 return $link->hrefXhtml ();

  330.         }

  331.         return null;

  332.     }

  333.     

  334.     public function getCover () {

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

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

  337.                 return $link->hrefXhtml ();

  338.         }

  339.         return null;

  340.     }

  341. }

  342. 

  343. class Page

  344. {

  345.     public $title;

  346.     public $subtitle = "";

  347.     public $idPage;

  348.     public $idGet;

  349.     public $query;

  350.     public $favicon;

  351.     public $n;

  352.     public $book;

  353.     public $totalNumber = -1;

  354.     public $entryArray = array();

  355.     

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

  357.     {

  358.         switch ($pageId) {

  359.             case Base::PAGE_ALL_AUTHORS :

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

  361.             case Base::PAGE_AUTHORS_FIRST_LETTER :

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

  363.             case Base::PAGE_AUTHOR_DETAIL :

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

  365.             case Base::PAGE_ALL_TAGS :

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

  367.             case Base::PAGE_TAG_DETAIL :

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

  369.             case Base::PAGE_ALL_LANGUAGES :

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

  371.             case Base::PAGE_LANGUAGE_DETAIL :

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

  373.             case Base::PAGE_ALL_CUSTOMS :

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

  375.             case Base::PAGE_CUSTOM_DETAIL :

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

  377.             case Base::PAGE_ALL_SERIES :

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

  379.             case Base::PAGE_ALL_BOOKS :

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

  381.             case Base::PAGE_ALL_BOOKS_LETTER:

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

  383.             case Base::PAGE_ALL_RECENT_BOOKS :

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

  385.             case Base::PAGE_SERIE_DETAIL : 

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

  387.             case Base::PAGE_OPENSEARCH_QUERY :

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

  389.             case Base::PAGE_BOOK_DETAIL :

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

  391.             case Base::PAGE_ABOUT :

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

  393.             case Base::PAGE_CUSTOMIZE : 

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

  395.             default:

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

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

  398.                 return $page;

  399.         }

  400.     }

  401.     

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

  403.         global $config;

  404.         

  405.         $this->idGet = $pid;

  406.         $this->query = $pquery;

  407.         $this->n = $pn;

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

  409.     }

  410.     

  411.     public function InitializeContent () 

  412.     {

  413.         global $config;

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

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

  416.         $database = GetUrlParam (DB);

  417.         if (is_array ($config['calibre_directory']) && is_null ($database)) {

  418.             $i = 0;

  419.             foreach ($config['calibre_directory'] as $key => $value) {

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

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

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

  423.                                         array ( new LinkNavigation ("?" . DB . "={$i}"))));

  424.                 $i++;

  425.                 Base::clearDb ();

  426.             }

  427.         } else {

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

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

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

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

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

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

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

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

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

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

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

  439.                 }

  440.             }

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

  442.             

  443.             if (!is_null ($database)) $this->title =  Base::getDbName ();

  444.         }

  445.     }

  446. 

  447.     public function isPaginated ()

  448.     {

  449.         global $config;

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

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

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

  453.     }

  454.     

  455.     public function getNextLink ()

  456.     {

  457.         global $config;

  458.         $currentUrl = $_SERVER['QUERY_STRING'];

  459.         $currentUrl = preg_replace ("/\&n=.*?$/", "", "?" . $_SERVER['QUERY_STRING']);

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

  461.             return new LinkNavigation ($currentUrl . "&n=" . ($this->n + 1), "next", "Page suivante");

  462.         }

  463.         return NULL;

  464.     }

  465.     

  466.     public function getPrevLink ()

  467.     {

  468.         global $config;

  469.         $currentUrl = $_SERVER['QUERY_STRING'];

  470.         $currentUrl = preg_replace ("/\&n=.*?$/", "", "?" . $_SERVER['QUERY_STRING']);

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

  472.             return new LinkNavigation ($currentUrl . "&n=" . ($this->n - 1), "previous", "Page precedente");

  473.         }

  474.         return NULL;

  475.     }

  476.     

  477.     public function getMaxPage ()

  478.     {

  479.         global $config;

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

  481.     }

  482.     

  483.     public function containsBook ()

  484.     {

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

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

  487.         return false;

  488.     }

  489. 

  490. }

  491. 

  492. class PageAllAuthors extends Page

  493. {

  494.     public function InitializeContent () 

  495.     {

  496.         global $config;

  497.         

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

  499.         if ($config['cops_author_split_first_letter'] == 1) {

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

  501.         }

  502.         else {

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

  504.         }

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

  506.     }

  507. }

  508. 

  509. class PageAllAuthorsLetter extends Page

  510. {

  511.     public function InitializeContent () 

  512.     {

  513.         global $config;

  514.         

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

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

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

  518.     }

  519. }

  520. 

  521. class PageAuthorDetail extends Page

  522. {

  523.     public function InitializeContent () 

  524.     {

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

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

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

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

  529.     }

  530. }

  531. 

  532. class PageAllTags extends Page

  533. {

  534.     public function InitializeContent () 

  535.     {

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

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

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

  539.     }

  540. }

  541. 

  542. class PageAllLanguages extends Page

  543. {

  544.     public function InitializeContent () 

  545.     {

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

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

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

  549.     }

  550. }

  551. 

  552. class PageCustomDetail extends Page

  553. {

  554.     public function InitializeContent () 

  555.     {

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

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

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

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

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

  561.     }

  562. }

  563. 

  564. class PageAllCustoms extends Page

  565. {

  566.     public function InitializeContent () 

  567.     {

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

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

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

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

  572.     }

  573. }

  574. 

  575. class PageTagDetail extends Page

  576. {

  577.     public function InitializeContent () 

  578.     {

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

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

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

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

  583.     }

  584. }

  585. 

  586. class PageLanguageDetail extends Page

  587. {

  588.     public function InitializeContent () 

  589.     {

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

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

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

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

  594.     }

  595. }

  596. 

  597. class PageAllSeries extends Page

  598. {

  599.     public function InitializeContent () 

  600.     {

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

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

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

  604.     }

  605. }

  606. 

  607. class PageSerieDetail extends Page

  608. {

  609.     public function InitializeContent () 

  610.     {

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

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

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

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

  615.     }

  616. }

  617. 

  618. class PageAllBooks extends Page

  619. {

  620.     public function InitializeContent () 

  621.     {

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

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

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

  625.     }

  626. }

  627. 

  628. class PageAllBooksLetter extends Page

  629. {

  630.     public function InitializeContent () 

  631.     {

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

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

  634.         

  635.         $count = $this->totalNumber;

  636.         if ($count == -1)

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

  638.         

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

  640.     }

  641. }

  642. 

  643. class PageRecentBooks extends Page

  644. {

  645.     public function InitializeContent () 

  646.     {

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

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

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

  650.     }

  651. }

  652. 

  653. class PageQueryResult extends Page

  654. {

  655.     public function InitializeContent () 

  656.     {

  657.         global $config;

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

  659.         $currentPage = getURLParam ("current", NULL);

  660.         

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

  662.         if (is_array ($config['calibre_directory']) && is_null (GetUrlParam (DB))) {

  663.             $i = 0;

  664.             foreach ($config['calibre_directory'] as $key => $value) {

  665.                 Base::clearDb ();

  666.                 list ($array, $totalNumber) = Book::getBooksByQuery ($this->query, $this->n, $i);

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

  668.                                         str_format (localize ("bookword", count($array)), count($array)), "text", 

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

  670.                 $i++;

  671.             }

  672.             return;

  673.         }

  674.         

  675.         switch ($currentPage) {

  676.             case Base::PAGE_ALL_AUTHORS :

  677.             case Base::PAGE_AUTHORS_FIRST_LETTER :

  678.                 $this->entryArray = Author::getAuthorsByStartingLetter ('%' . $this->query);

  679.                 break;

  680.             default:

  681.                 list ($this->entryArray, $this->totalNumber) = Book::getBooksByQuery ($this->query, $this->n);

  682.         }

  683.     }

  684. }

  685. 

  686. class PageBookDetail extends Page

  687. {

  688.     public function InitializeContent () 

  689.     {

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

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

  692.     }

  693. }

  694. 

  695. class PageAbout extends Page

  696. {

  697.     public function InitializeContent () 

  698.     {

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

  700.     }

  701. }

  702. 

  703. class PageCustomize extends Page

  704. {

  705.     public function InitializeContent () 

  706.     {

  707.         global $config;

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

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

  710.         

  711.         $use_fancybox = "";

  712.         if (getCurrentOption ("use_fancyapps") == 1) {

  713.             $use_fancybox = "checked='checked'";

  714.         }

  715.         $html_tag_filter = "";

  716.         if (getCurrentOption ("html_tag_filter") == 1) {

  717.             $html_tag_filter = "checked='checked'";

  718.         }

  719.         

  720.         

  721.         $content = "";

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

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

  724.         }

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

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

  727.                     $filename = $m [1];

  728.                 }

  729.                 $selected = "";

  730.                 if (getCurrentOption ("style") == $filename) {

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

  732.                         $selected = "selected='selected'";

  733.                     } else {

  734.                         $selected = "checked='checked'";

  735.                     }

  736.                 }

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

  738.                     $content .= "<option value='{$filename}' {$selected}>{$filename}</option>";

  739.                 } else {

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

  741.                 }

  742.             }

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

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

  745.         }

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

  747.                                         $content, "text", 

  748.                                         array ()));

  749.         

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

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

  752.                                         $content, "text", 

  753.                                         array ()));

  754.         $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]+$" />';

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

  756.                                         $content, "text", 

  757.                                         array ()));

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

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

  760.                                         $content, "text", 

  761.                                         array ()));

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

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

  764.                                         $content, "text", 

  765.                                         array ()));

  766.     }

  767. }

  768. 

  769. 

  770. abstract class Base

  771. {

  772.     const PAGE_INDEX = "index";

  773.     const PAGE_ALL_AUTHORS = "1";

  774.     const PAGE_AUTHORS_FIRST_LETTER = "2";

  775.     const PAGE_AUTHOR_DETAIL = "3";

  776.     const PAGE_ALL_BOOKS = "4";

  777.     const PAGE_ALL_BOOKS_LETTER = "5";

  778.     const PAGE_ALL_SERIES = "6";

  779.     const PAGE_SERIE_DETAIL = "7";

  780.     const PAGE_OPENSEARCH = "8";

  781.     const PAGE_OPENSEARCH_QUERY = "9";

  782.     const PAGE_ALL_RECENT_BOOKS = "10";

  783.     const PAGE_ALL_TAGS = "11";

  784.     const PAGE_TAG_DETAIL = "12";

  785.     const PAGE_BOOK_DETAIL = "13";

  786.     const PAGE_ALL_CUSTOMS = "14";

  787.     const PAGE_CUSTOM_DETAIL = "15";

  788.     const PAGE_ABOUT = "16";

  789.     const PAGE_ALL_LANGUAGES = "17";

  790.     const PAGE_LANGUAGE_DETAIL = "18";   

  791.     const PAGE_CUSTOMIZE = "19"; 

  792. 

  793.     const COMPATIBILITY_XML_ALDIKO = "aldiko";

  794.     

  795.     private static $db = NULL;

  796.     

  797.     public static function getDbList () {

  798.         global $config;

  799.         if (is_array ($config['calibre_directory'])) {

  800.             return $config['calibre_directory'];

  801.         } else {

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

  803.         }

  804.     }

  805. 

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

  807.         global $config;

  808.         if (is_array ($config['calibre_directory'])) {

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

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

  811.             return  $array[$database];

  812.         }

  813.         return "";

  814.     }

  815. 

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

  817.         global $config;

  818.         if (is_array ($config['calibre_directory'])) {

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

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

  821.             return  $array[$database];

  822.         }

  823.         return $config['calibre_directory'];

  824.     }

  825. 

  826.   

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

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

  829.     }

  830.     

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

  832.         global $config;

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

  834.             try {

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

  836.             } catch (Exception $e) {

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

  838.                 exit();

  839.             }

  840.         }

  841.         return self::$db;

  842.     }

  843.     

  844.     public static function clearDb () {

  845.         self::$db = NULL;

  846.     }

  847.     

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

  849.         global $config;

  850.         $totalResult = -1;

  851.         

  852.         if (getCurrentOption ("max_item_per_page") != -1 && $n != -1)

  853.         {

  854.             // First check total number of results

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

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

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

  858.             

  859.             // Next modify the query and params

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

  861.             array_push ($params, ($n - 1) * getCurrentOption ("max_item_per_page"), getCurrentOption ("max_item_per_page"));

  862.         }

  863.         

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

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

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

  867.     }

  868. 

  869. }