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

1158 lines
40KB
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.9.1beta");

  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.     $header = file_get_contents('templates/default/header.html');

  22.     $footer = file_get_contents('templates/default/footer.html');

  23.     $main = file_get_contents('templates/default/main.html');

  24.     $bookdetail = file_get_contents('templates/default/bookdetail.html');

  25.     $page = file_get_contents('templates/default/page.html');

  26. 

  27.     // Generate the function for the template

  28.     $template = new doT ();

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

  30.                                               "header" => $header,

  31.                                               "footer" => $footer,

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

  33.     // Execute the template

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

  35.         return $dot ($data);

  36.     }

  37. 

  38.     return NULL;

  39. }

  40. 

  41. function getQueryString () {

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

  43.         return $_SERVER['QUERY_STRING'];

  44.     }

  45.     return "";

  46. }

  47. 

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

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

  50.         return $_GET[$name];

  51.     }

  52.     return $default;

  53. }

  54. 

  55. function getCurrentOption ($option) {

  56.     global $config;

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

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

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

  60.         } else {

  61.             return $_COOKIE[$option];

  62.         }

  63.     }

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

  65.         return "default";

  66.     }

  67. 

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

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

  70.     }

  71. 

  72.     return "";

  73. }

  74. 

  75. function getCurrentCss () {

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

  77. }

  78. 

  79. function getUrlWithVersion ($url) {

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

  81. }

  82. 

  83. function xml2xhtml($xml) {

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

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

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

  87.     '), $xml);

  88. }

  89. 

  90. function display_xml_error($error)

  91. {

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

  93. 

  94.     switch ($error->level) {

  95.         case LIBXML_ERR_WARNING:

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

  97.             break;

  98.          case LIBXML_ERR_ERROR:

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

  100.             break;

  101.         case LIBXML_ERR_FATAL:

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

  103.             break;

  104.     }

  105. 

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

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

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

  109. 

  110.     if ($error->file) {

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

  112.     }

  113. 

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

  115. }

  116. 

  117. function are_libxml_errors_ok ()

  118. {

  119.     $errors = libxml_get_errors();

  120. 

  121.     foreach ($errors as $error) {

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

  123.     }

  124.     return true;

  125. }

  126. 

  127. function html2xhtml ($html) {

  128.     $doc = new DOMDocument();

  129.     libxml_use_internal_errors(true);

  130. 

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

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

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

  134.     $output = xml2xhtml($output);

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

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

  137.     }

  138.     /*

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

  140.     $errors = libxml_get_errors();

  141. 

  142.     foreach ($errors as $error) {

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

  144.     }

  145.     */

  146. 

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

  148. 

  149.     libxml_use_internal_errors(false);

  150.     return $output;

  151. }

  152. 

  153. /**

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

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

  156.  */

  157. function str_format($format) {

  158.     $args = func_get_args();

  159.     $format = array_shift($args);

  160. 

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

  162.     $offset = 0;

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

  164.         $i = $data[0];

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

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

  167.     }

  168. 

  169.     return $format;

  170. }

  171. 

  172. /**

  173.  * This method is based on this page

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

  175.  */

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

  177.     if ($count == 0)

  178.         $phrase .= ".none";

  179.     if ($count == 1)

  180.         $phrase .= ".one";

  181.     if ($count > 1)

  182.         $phrase .= ".many";

  183. 

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

  185.     static $translations = NULL;

  186.     if ($reset) {

  187.         $translations = NULL;

  188.     }

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

  190.     if (is_null($translations)) {

  191.         $lang = "en";

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

  193.         {

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

  195.         }

  196.         $lang_file_en = NULL;

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

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

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

  200.         }

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

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

  203.         }

  204.         $lang_file_content = file_get_contents($lang_file);

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

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

  207. 

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

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

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

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

  212.             }

  213.         }

  214.         if ($lang_file_en)

  215.         {

  216.             $lang_file_content = file_get_contents($lang_file_en);

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

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

  219.         }

  220.     }

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

  222.         return $translations[$phrase];

  223.     }

  224.     return $phrase;

  225. }

  226. 

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

  228.     if (empty ($urlParams)) {

  229.         $urlParams = "";

  230.     }

  231.     $start = "";

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

  233.         $start = "?";

  234.         $urlParams = $matches[1];

  235.     }

  236.     $params = array();

  237.     parse_str($urlParams, $params);

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

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

  240.     } else {

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

  242.     }

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

  244. }

  245. 

  246. class Link

  247. {

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

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

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

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

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

  253. 

  254.     public $href;

  255.     public $type;

  256.     public $rel;

  257.     public $title;

  258.     public $facetGroup;

  259.     public $activeFacet;

  260. 

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

  262.         $this->href = $phref;

  263.         $this->type = $ptype;

  264.         $this->rel = $prel;

  265.         $this->title = $ptitle;

  266.         $this->facetGroup = $pfacetGroup;

  267.         $this->activeFacet = $pactiveFacet;

  268.     }

  269. 

  270.     public function hrefXhtml () {

  271.         return $this->href;

  272.     }

  273. }

  274. 

  275. class LinkNavigation extends Link

  276. {

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

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

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

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

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

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

  283.         } else {

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

  285.         }

  286.     }

  287. }

  288. 

  289. class LinkFacet extends Link

  290. {

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

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

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

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

  295.     }

  296. }

  297. 

  298. class Entry

  299. {

  300.     public $title;

  301.     public $id;

  302.     public $content;

  303.     public $contentType;

  304.     public $linkArray;

  305.     public $localUpdated;

  306.     public $className;

  307.     private static $updated = NULL;

  308. 

  309.     public static $icons = array(

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

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

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

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

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

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

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

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

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

  319.     );

  320. 

  321.     public function getUpdatedTime () {

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

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

  324.         }

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

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

  327.         }

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

  329.     }

  330. 

  331.     public function getNavLink () {

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

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

  334. 

  335.             return $link->hrefXhtml ();

  336.         }

  337.         return "#";

  338.     }

  339. 

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

  341.         global $config;

  342.         $this->title = $ptitle;

  343.         $this->id = $pid;

  344.         $this->content = $pcontent;

  345.         $this->contentType = $pcontentType;

  346.         $this->linkArray = $plinkArray;

  347.         $this->className = $pclass;

  348. 

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

  350.         {

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

  352.             {

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

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

  355.                     break;

  356.                 }

  357.             }

  358.         }

  359. 

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

  361.     }

  362. }

  363. 

  364. class EntryBook extends Entry

  365. {

  366.     public $book;

  367. 

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

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

  370.         $this->book = $pbook;

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

  372.     }

  373. 

  374.     public function getCoverThumbnail () {

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

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

  377.                 return $link->hrefXhtml ();

  378.         }

  379.         return null;

  380.     }

  381. 

  382.     public function getCover () {

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

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

  385.                 return $link->hrefXhtml ();

  386.         }

  387.         return null;

  388.     }

  389. }

  390. 

  391. class Page

  392. {

  393.     public $title;

  394.     public $subtitle = "";

  395.     public $authorName = "";

  396.     public $authorUri = "";

  397.     public $authorEmail = "";

  398.     public $idPage;

  399.     public $idGet;

  400.     public $query;

  401.     public $favicon;

  402.     public $n;

  403.     public $book;

  404.     public $totalNumber = -1;

  405.     public $entryArray = array();

  406. 

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

  408.     {

  409.         switch ($pageId) {

  410.             case Base::PAGE_ALL_AUTHORS :

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

  412.             case Base::PAGE_AUTHORS_FIRST_LETTER :

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

  414.             case Base::PAGE_AUTHOR_DETAIL :

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

  416.             case Base::PAGE_ALL_TAGS :

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

  418.             case Base::PAGE_TAG_DETAIL :

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

  420.             case Base::PAGE_ALL_LANGUAGES :

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

  422.             case Base::PAGE_LANGUAGE_DETAIL :

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

  424.             case Base::PAGE_ALL_CUSTOMS :

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

  426.             case Base::PAGE_CUSTOM_DETAIL :

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

  428.             case Base::PAGE_ALL_SERIES :

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

  430.             case Base::PAGE_ALL_BOOKS :

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

  432.             case Base::PAGE_ALL_BOOKS_LETTER:

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

  434.             case Base::PAGE_ALL_RECENT_BOOKS :

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

  436.             case Base::PAGE_SERIE_DETAIL :

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

  438.             case Base::PAGE_OPENSEARCH_QUERY :

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

  440.             case Base::PAGE_BOOK_DETAIL :

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

  442.             case Base::PAGE_ALL_PUBLISHERS:

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

  444.             case Base::PAGE_PUBLISHER_DETAIL :

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

  446.             case Base::PAGE_ABOUT :

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

  448.             case Base::PAGE_CUSTOMIZE :

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

  450.             default:

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

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

  453.                 return $page;

  454.         }

  455.     }

  456. 

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

  458.         global $config;

  459. 

  460.         $this->idGet = $pid;

  461.         $this->query = $pquery;

  462.         $this->n = $pn;

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

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

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

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

  467.     }

  468. 

  469.     public function InitializeContent ()

  470.     {

  471.         global $config;

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

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

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

  475.             $i = 0;

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

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

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

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

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

  481.                 $i++;

  482.                 Base::clearDb ();

  483.             }

  484.         } else {

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

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

  487.             }

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

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

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

  491.             }

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

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

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

  495.             }

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

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

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

  499.             }

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

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

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

  503.             }

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

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

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

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

  508.                 }

  509.             }

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

  511. 

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

  513.         }

  514.     }

  515. 

  516.     public function isPaginated ()

  517.     {

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

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

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

  521.     }

  522. 

  523.     public function getNextLink ()

  524.     {

  525.         $currentUrl = getQueryString ();

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

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

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

  529.         }

  530.         return NULL;

  531.     }

  532. 

  533.     public function getPrevLink ()

  534.     {

  535.         $currentUrl = getQueryString ();

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

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

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

  539.         }

  540.         return NULL;

  541.     }

  542. 

  543.     public function getMaxPage ()

  544.     {

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

  546.     }

  547. 

  548.     public function containsBook ()

  549.     {

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

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

  552.         return false;

  553.     }

  554. 

  555.     public function getContentArrayTypeahead () {

  556.         $out = array ();

  557.         foreach ($this->entryArray as $entry) {

  558.             if ($entry instanceof EntryBook) {

  559.                 array_push ($out, array ("class" => $entry->className, "title" => $entry->title, "navlink" => $entry->book->getDetailUrl ()));

  560.             } else {

  561.                 if (empty ($entry->className) xor Base::noDatabaseSelected ()) {

  562.                     array_push ($out, array ("class" => $entry->className, "title" => $entry->title, "navlink" => $entry->getNavLink ()));

  563.                 } else {

  564.                     array_push ($out, array ("class" => $entry->className, "title" => $entry->content, "navlink" => $entry->getNavLink ()));

  565.                 }

  566.             }

  567.         }

  568.         return $out;

  569.     }

  570. 

  571. }

  572. 

  573. class PageAllAuthors extends Page

  574. {

  575.     public function InitializeContent ()

  576.     {

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

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

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

  580.         }

  581.         else {

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

  583.         }

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

  585.     }

  586. }

  587. 

  588. class PageAllAuthorsLetter extends Page

  589. {

  590.     public function InitializeContent ()

  591.     {

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

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

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

  595.     }

  596. }

  597. 

  598. class PageAuthorDetail extends Page

  599. {

  600.     public function InitializeContent ()

  601.     {

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

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

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

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

  606.     }

  607. }

  608. 

  609. class PageAllPublishers extends Page

  610. {

  611.     public function InitializeContent ()

  612.     {

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

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

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

  616.     }

  617. }

  618. 

  619. class PagePublisherDetail extends Page

  620. {

  621.     public function InitializeContent ()

  622.     {

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

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

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

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

  627.     }

  628. }

  629. 

  630. class PageAllTags extends Page

  631. {

  632.     public function InitializeContent ()

  633.     {

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

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

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

  637.     }

  638. }

  639. 

  640. class PageAllLanguages extends Page

  641. {

  642.     public function InitializeContent ()

  643.     {

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

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

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

  647.     }

  648. }

  649. 

  650. class PageCustomDetail extends Page

  651. {

  652.     public function InitializeContent ()

  653.     {

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

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

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

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

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

  659.     }

  660. }

  661. 

  662. class PageAllCustoms extends Page

  663. {

  664.     public function InitializeContent ()

  665.     {

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

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

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

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

  670.     }

  671. }

  672. 

  673. class PageTagDetail extends Page

  674. {

  675.     public function InitializeContent ()

  676.     {

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

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

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

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

  681.     }

  682. }

  683. 

  684. class PageLanguageDetail extends Page

  685. {

  686.     public function InitializeContent ()

  687.     {

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

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

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

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

  692.     }

  693. }

  694. 

  695. class PageAllSeries extends Page

  696. {

  697.     public function InitializeContent ()

  698.     {

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

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

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

  702.     }

  703. }

  704. 

  705. class PageSerieDetail extends Page

  706. {

  707.     public function InitializeContent ()

  708.     {

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

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

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

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

  713.     }

  714. }

  715. 

  716. class PageAllBooks extends Page

  717. {

  718.     public function InitializeContent ()

  719.     {

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

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

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

  723.         }

  724.         else {

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

  726.         }

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

  728.     }

  729. }

  730. 

  731. class PageAllBooksLetter extends Page

  732. {

  733.     public function InitializeContent ()

  734.     {

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

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

  737. 

  738.         $count = $this->totalNumber;

  739.         if ($count == -1)

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

  741. 

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

  743.     }

  744. }

  745. 

  746. class PageRecentBooks extends Page

  747. {

  748.     public function InitializeContent ()

  749.     {

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

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

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

  753.     }

  754. }

  755. 

  756. class PageQueryResult extends Page

  757. {

  758.     const SCOPE_TAG = "tag";

  759.     const SCOPE_SERIES = "series";

  760.     const SCOPE_AUTHOR = "author";

  761.     const SCOPE_BOOK = "book";

  762.     const SCOPE_PUBLISHER = "publisher";

  763. 

  764.     private function useTypeahead () {

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

  766.     }

  767. 

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

  769.         $n = $this->n;

  770.         $numberPerPage = NULL;

  771.         if ($limit) {

  772.             $n = 1;

  773.             $numberPerPage = 5;

  774.         }

  775.         switch ($scope) {

  776.             case self::SCOPE_BOOK :

  777.                 $array = Book::getBooksByStartingLetter ('%' . $this->query, $n, NULL, $numberPerPage);

  778.                 break;

  779.             case self::SCOPE_AUTHOR :

  780.                 $array = Author::getAuthorsByStartingLetter ('%' . $this->query);

  781.                 break;

  782.             case self::SCOPE_SERIES :

  783.                 $array = Serie::getAllSeriesByQuery ($this->query);

  784.                 break;

  785.             case self::SCOPE_TAG :

  786.                 $array = Tag::getAllTagsByQuery ($this->query, $n, NULL, $numberPerPage);

  787.                 break;

  788.             case self::SCOPE_PUBLISHER :

  789.                 $array = Publisher::getAllPublishersByQuery ($this->query);

  790.                 break;

  791.             default:

  792.                 $array = Book::getBooksByQuery (

  793.                     array ("all" => "%" . $this->query . "%"), $n);

  794.         }

  795. 

  796.         return $array;

  797.     }

  798. 

  799.     public function doSearchByCategory () {

  800.         $database = GetUrlParam (DB);

  801.         $out = array ();

  802.         $pagequery = Base::PAGE_OPENSEARCH_QUERY;

  803.         $dbArray = array ("");

  804.         $d = $database;

  805.         $query = $this->query;

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

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

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

  809.             $d = 0;

  810.         }

  811.         foreach ($dbArray as $key) {

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

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

  814.                                         " ", "text",

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

  816.                 Base::getDb ($d);

  817.             }

  818.             foreach (array (PageQueryResult::SCOPE_BOOK,

  819.                             PageQueryResult::SCOPE_AUTHOR,

  820.                             PageQueryResult::SCOPE_SERIES,

  821.                             PageQueryResult::SCOPE_TAG,

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

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

  824.                     continue;

  825.                 }

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

  827. 

  828.                 $i = 0;

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

  830.                     $total = $array [1];

  831.                     $array = $array [0];

  832.                 } else {

  833.                     $total = count($array);

  834.                 }

  835.                 if ($total > 0) {

  836.                     // Comment to help the perl i18n script

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

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

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

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

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

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

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

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

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

  846.                 }

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

  848.                     foreach ($array as $entry) {

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

  850.                         $i++;

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

  852.                     }

  853.                 }

  854.             }

  855.             $d++;

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

  857.                 Base::clearDb ();

  858.             }

  859.         }

  860.         return $out;

  861.     }

  862. 

  863.     public function InitializeContent ()

  864.     {

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

  866.         if (empty ($scope)) {

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

  868.         } else {

  869.             // Comment to help the perl i18n script

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

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

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

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

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

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

  876.         }

  877. 

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

  879. 

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

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

  882.             $i = 0;

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

  884.                 Base::clearDb ();

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

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

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

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

  889.                 $i++;

  890.             }

  891.             return;

  892.         }

  893.         if (empty ($scope)) {

  894.             $this->doSearchByCategory ();

  895.             return;

  896.         }

  897. 

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

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

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

  901.         } else {

  902.             $this->entryArray = $array;

  903.         }

  904.     }

  905. }

  906. 

  907. class PageBookDetail extends Page

  908. {

  909.     public function InitializeContent ()

  910.     {

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

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

  913.     }

  914. }

  915. 

  916. class PageAbout extends Page

  917. {

  918.     public function InitializeContent ()

  919.     {

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

  921.     }

  922. }

  923. 

  924. class PageCustomize extends Page

  925. {

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

  927.         $value = getCurrentOption ($key);

  928.         if (is_array ($value)) {

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

  930.                 return "checked='checked'";

  931.             }

  932.         } else {

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

  934.                 return "checked='checked'";

  935.             }

  936.         }

  937.         return "";

  938.     }

  939. 

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

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

  942.             return "selected='selected'";

  943.         }

  944.         return "";

  945.     }

  946. 

  947.     private function getStyleList () {

  948.         $result = array ();

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

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

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

  952.             }

  953.         }

  954.         return $result;

  955.     }

  956. 

  957.     public function InitializeContent ()

  958.     {

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

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

  961. 

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

  963.                                    PageQueryResult::SCOPE_TAG,

  964.                                    PageQueryResult::SCOPE_SERIES,

  965.                                    PageQueryResult::SCOPE_PUBLISHER,

  966.                                    "language");

  967. 

  968.         $content = "";

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

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

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

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

  973.             }

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

  975.         } else {

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

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

  978.             }

  979.         }

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

  981.                                         $content, "text",

  982.                                         array ()));

  983.         if (!useServerSideRendering ()) {

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

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

  986.                                             $content, "text",

  987.                                             array ()));

  988.         }

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

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

  991.                                         $content, "text",

  992.                                         array ()));

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

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

  995.                                         $content, "text",

  996.                                         array ()));

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

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

  999.                                         $content, "text",

  1000.                                         array ()));

  1001.         $content = "";

  1002.         foreach ($ignoredBaseArray as $key) {

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

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

  1005.         }

  1006. 

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

  1008.                                         $content, "text",

  1009.                                         array ()));

  1010.     }

  1011. }

  1012. 

  1013. 

  1014. abstract class Base

  1015. {

  1016.     const PAGE_INDEX = "index";

  1017.     const PAGE_ALL_AUTHORS = "1";

  1018.     const PAGE_AUTHORS_FIRST_LETTER = "2";

  1019.     const PAGE_AUTHOR_DETAIL = "3";

  1020.     const PAGE_ALL_BOOKS = "4";

  1021.     const PAGE_ALL_BOOKS_LETTER = "5";

  1022.     const PAGE_ALL_SERIES = "6";

  1023.     const PAGE_SERIE_DETAIL = "7";

  1024.     const PAGE_OPENSEARCH = "8";

  1025.     const PAGE_OPENSEARCH_QUERY = "9";

  1026.     const PAGE_ALL_RECENT_BOOKS = "10";

  1027.     const PAGE_ALL_TAGS = "11";

  1028.     const PAGE_TAG_DETAIL = "12";

  1029.     const PAGE_BOOK_DETAIL = "13";

  1030.     const PAGE_ALL_CUSTOMS = "14";

  1031.     const PAGE_CUSTOM_DETAIL = "15";

  1032.     const PAGE_ABOUT = "16";

  1033.     const PAGE_ALL_LANGUAGES = "17";

  1034.     const PAGE_LANGUAGE_DETAIL = "18";

  1035.     const PAGE_CUSTOMIZE = "19";

  1036.     const PAGE_ALL_PUBLISHERS = "20";

  1037.     const PAGE_PUBLISHER_DETAIL = "21";

  1038. 

  1039.     const COMPATIBILITY_XML_ALDIKO = "aldiko";

  1040. 

  1041.     private static $db = NULL;

  1042. 

  1043.     public static function isMultipleDatabaseEnabled () {

  1044.         global $config;

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

  1046.     }

  1047. 

  1048.     public static function noDatabaseSelected () {

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

  1050.     }

  1051. 

  1052.     public static function getDbList () {

  1053.         global $config;

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

  1055.             return $config['calibre_directory'];

  1056.         } else {

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

  1058.         }

  1059.     }

  1060. 

  1061.     public static function getDbNameList () {

  1062.         global $config;

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

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

  1065.         } else {

  1066.             return array ("");

  1067.         }

  1068.     }

  1069. 

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

  1071.         global $config;

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

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

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

  1075.             return  $array[$database];

  1076.         }

  1077.         return "";

  1078.     }

  1079. 

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

  1081.         global $config;

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

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

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

  1085.             return  $array[$database];

  1086.         }

  1087.         return $config['calibre_directory'];

  1088.     }

  1089. 

  1090. 

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

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

  1093.     }

  1094. 

  1095.     private static function error () {

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

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

  1098.         }

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

  1100.     }

  1101. 

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

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

  1104.             try {

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

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

  1107.                 } else {

  1108.                     self::error ();

  1109.                 }

  1110.             } catch (Exception $e) {

  1111.                 self::error ();

  1112.             }

  1113.         }

  1114.         return self::$db;

  1115.     }

  1116. 

  1117.     public static function checkDatabaseAvailability () {

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

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

  1120.                 self::getDb ($i);

  1121.                 self::clearDb ();

  1122.             }

  1123.         } else {

  1124.             self::getDb ();

  1125.         }

  1126.         return true;

  1127.     }

  1128. 

  1129.     public static function clearDb () {

  1130.         self::$db = NULL;

  1131.     }

  1132. 

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

  1134.         $totalResult = -1;

  1135. 

  1136.         if (is_null ($numberPerPage)) {

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

  1138.         }

  1139. 

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

  1141.         {

  1142.             // First check total number of results

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

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

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

  1146. 

  1147.             // Next modify the query and params

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

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

  1150.         }

  1151. 

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

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

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

  1155.     }

  1156. 

  1157. }