Merge pull request #188 from kiwix/create_directory

Create the datadirectory to not fail to write the aria2 session file.

ChangeLog

@@ -1,3 +1,39 @@
+kiwix-lib 3.1.1
+===============
+
+ * The OPDS feed book's date must be the date of the book, not the date of the
+ feed generation.
+ * Convert the standard opds date to our format (YYYY-MM-DD)
+ * Remove duplicate language attribute in the libxml dumper.
+ * Create the datadirectory to not fail to write a file in a non-existent
+   directory
+
+kiwix-lib 3.1.0
+===============
+
+ * Add a method to get the favicon url of book (if available).
+ * Move dump code of library.xml in a specific class.
+ * Add a first support to bookmarks
+
+kiwix-lib 3.0.3
+===============
+
+ * Add the 'en' language to the mapping alpha2-code ('en') to alpha3-code
+ ('eng').
+ * Correctly write the 'ArticleCount' and 'MediaCount' in the library.xml.
+ * Correctly fill the book size for the zim file size.
+ * Fix launch of aria2c.
+
+kiwix-lib 3.0.2
+===============
+
+ * Use the correct path separator when computing relativePath on Windows.
+
+kiwix-lib 3.0.1
+===============
+
+ * Small fix about parsing the opdsStream.
+
 kiwix-lib 3.0.0
 ===============
 

include/book.h

@@ -68,6 +68,7 @@ class Book
   const uint64_t& getMediaCount() const { return m_mediaCount; }
   const uint64_t& getSize() const { return m_size; }
   const std::string& getFavicon() const;
+  const std::string& getFaviconUrl() const { return m_faviconUrl; }
   const std::string& getFaviconMimeType() const { return m_faviconMimeType; }
   const std::string& getDownloadId() const { return m_downloadId; }
 

include/bookmark.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_BOOKMARK_H
+#define KIWIX_BOOKMARK_H
+
+#include <string>
+
+namespace pugi {
+class xml_node;
+}
+
+namespace kiwix
+{
+
+/**
+ * A class to store information about a bookmark (an article in a book)
+ */
+class Bookmark
+{
+ public:
+  Bookmark();
+  ~Bookmark();
+
+  void updateFromXml(const pugi::xml_node& node);
+
+  const std::string& getBookId() const { return m_bookId; }
+  const std::string& getBookTitle()  const { return m_bookTitle; }
+  const std::string& getUrl() const { return m_url; }
+  const std::string& getTitle() const { return m_title; }
+  const std::string& getLanguage() const { return m_language; }
+  const std::string& getDate() const { return m_date; }
+
+  void setBookId(const std::string& bookId) { m_bookId = bookId; }
+  void setBookTitle(const std::string& bookTitle) { m_bookTitle = bookTitle; }
+  void setUrl(const std::string& url) { m_url = url; }
+  void setTitle(const std::string& title) { m_title = title; }
+  void setLanguage(const std::string& language) { m_language = language; }
+  void setDate(const std::string& date) { m_date = date; }
+
+ protected:
+  std::string m_bookId;
+  std::string m_bookTitle;
+  std::string m_url;
+  std::string m_title;
+  std::string m_language;
+  std::string m_date;
+};
+
+}
+
+#endif

include/common/stringTools.h

@@ -71,5 +71,13 @@ std::string to_string(T value)
     oss << value;
     return oss.str();
 }
+
+template<typename T>
+T extractFromString(const std::string& str) {
+    std::istringstream iss(str);
+    T ret;
+    iss >> ret;
+    return ret;
+}
 } //namespace kiwix
 #endif

include/library.h

@@ -24,12 +24,14 @@
 #include <vector>
 #include <map>
 
+#include "book.h"
+#include "bookmark.h"
+
 #define KIWIX_LIBRARY_VERSION "20110515"
 
 namespace kiwix
 {
 
-class Book;
 class OPDSDumper;
 
 enum supportedListSortBy { UNSORTED, TITLE, SIZE, DATE, CREATOR, PUBLISHER };
@@ -47,12 +49,13 @@ enum supportedListMode {
  */
 class Library
 {
-  std::map<std::string, kiwix::Book> books;
+  std::map<std::string, kiwix::Book> m_books;
+  std::vector<kiwix::Bookmark> m_bookmarks;
+
  public:
   Library();
   ~Library();
 
-  std::string version;
   /**
    * Add a book to the library.
    *
@@ -65,6 +68,22 @@ class Library
    */
   bool addBook(const Book& book);
 
+  /**
+   * Add a bookmark to the library.
+   *
+   * @param bookmark the book to add.
+   */
+  void addBookmark(const Bookmark& bookmark);
+
+  /**
+   * Remove a bookmarkk
+   *
+   * @param zimId The zimId of the bookmark.
+   * @param url The url of the bookmark.
+   * @return True if the bookmark has been removed.
+   */
+  bool removeBookmark(const std::string& zimId, const std::string& url);
+
   Book& getBookById(const std::string& id);
 
   /**
@@ -79,10 +98,18 @@ class Library
    * Write the library to a file.
    *
    * @param path the path of the file to write to.
-   * @return True if the library has been correctly save.
+   * @return True if the library has been correctly saved.
    */
   bool writeToFile(const std::string& path);
 
+  /**
+   * Write the library bookmarks to a file.
+   *
+   * @param path the path of the file to write to.
+   * @return True if the library has been correctly saved.
+   */
+  bool writeBookmarksToFile(const std::string& path);
+
   /**
    * Get the number of book in the library.
    *
@@ -113,6 +140,13 @@ class Library
    */
   std::vector<std::string> getBooksPublishers();
 
+  /**
+   * Get all bookmarks.
+   *
+   * @return A list of bookmarks
+   */
+  const std::vector<kiwix::Bookmark>& getBookmarks() { return m_bookmarks; }
+
   /**
    * Get all book ids of the books in the library.
    *
@@ -163,6 +197,7 @@ class Library
     size_t maxSize = 0);
 
   friend class OPDSDumper;
+  friend class libXMLDumper;
 };
 }
 

include/libxml_dumper.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#ifndef KIWIX_LIBXML_DUMPER_H
+#define KIWIX_LIBXML_DUMPER_H
+
+#include <string>
+#include <vector>
+
+#include <pugixml.hpp>
+
+#include "library.h"
+
+namespace kiwix
+{
+
+/**
+ * A tool to dump a `Library` into a basic library.xml
+ *
+ */
+class LibXMLDumper
+{
+ public:
+  LibXMLDumper() = default;
+  LibXMLDumper(Library* library);
+  ~LibXMLDumper();
+
+  /**
+   * Dump the library.xml
+   *
+   * @param id The id of the library.
+   * @return The library.xml content.
+   */
+  std::string dumpLibXMLContent(const std::vector<std::string>& bookIds);
+
+
+  /**
+   * Dump the bookmark of the library.
+   *
+   * @return The bookmark.xml content.
+   */
+  std::string dumpLibXMLBookmark();
+
+  /**
+   * Set the base directory used.
+   *
+   * @param baseDir the base directory to use.
+   */
+  void setBaseDir(const std::string& baseDir) { this->baseDir = baseDir; }
+
+  /**
+   * Set the library to dump.
+   *
+   * @param library The library to dump.
+   */
+  void setLibrary(Library* library) { this->library = library; }
+
+ protected:
+  kiwix::Library* library;
+  std::string baseDir;
+ private:
+  void handleBook(Book book, pugi::xml_node root_node);
+  void handleBookmark(Bookmark bookmark, pugi::xml_node root_node);
+};
+}
+
+#endif // KIWIX_OPDS_DUMPER_H

include/manager.h

@@ -38,6 +38,7 @@ class LibraryManipulator {
  public:
   virtual ~LibraryManipulator() {}
   virtual bool addBookToLibrary(Book book) = 0;
+  virtual void addBookmarkToLibrary(Bookmark bookmark) = 0;
 };
 
 class DefaultLibraryManipulator : public LibraryManipulator {
@@ -48,6 +49,9 @@ class DefaultLibraryManipulator : public LibraryManipulator {
   bool addBookToLibrary(Book book) {
     return library->addBook(book);
   }
+  void addBookmarkToLibrary(Bookmark bookmark) {
+    library->addBookmark(bookmark);
+  }
  private:
    kiwix::Library* library;
 };
@@ -113,6 +117,15 @@ class Manager
    */
   bool readOpds(const std::string& content, const std::string& urlHost);
 
+
+  /**
+   * Load a bookmark file.
+   *
+   * @param path The path of the file to read.
+   * @return True if the content has been properly parsed.
+   */
+  bool readBookmarkFile(const std::string& path);
+
   /**
    * Add a book to the library.
    *
@@ -196,7 +209,10 @@ class Manager
 
   std::string writableLibraryPath;
 
-  std::vector<std::string> bookIdList;
+  bool m_hasSearchResult = false;
+  uint64_t m_totalBooks = 0;
+  uint64_t m_startIndex = 0;
+  uint64_t m_itemsPerPage = 0;
 
  protected:
   kiwix::LibraryManipulator* manipulator;

include/meson.build

@@ -1,8 +1,10 @@
 headers = [
   'book.h',
+  'bookmark.h',
   'common.h',
   'library.h',
   'manager.h',
+  'libxml_dumper.h',
   'opds_dumper.h',
   'downloader.h',
   'reader.h',

meson.build

@@ -1,5 +1,5 @@
 project('kiwix-lib', 'cpp',
-  version : '3.0.0',
+  version : '3.1.1',
   license : 'GPL',
   default_options : ['c_std=c11', 'cpp_std=c++11', 'werror=true'])
 

src/aria2.cpp

@@ -9,6 +9,13 @@
 #include <common/pathTools.h>
 #include <downloader.h> // For AriaError
 
+#ifdef _WIN32
+# define ARIA2_CMD "aria2c.exe"
+#else
+# define ARIA2_CMD "aria2c"
+#endif
+
+
 namespace kiwix {
 
 Aria2::Aria2():
@@ -19,6 +26,7 @@ Aria2::Aria2():
   m_lock(PTHREAD_MUTEX_INITIALIZER)
 {
   m_downloadDir = getDataDirectory();
+  makeDirectory(m_downloadDir);
   std::vector<const char*> callCmd;
 
   std::string rpc_port = "--rpc-listen-port=" + to_string(m_port);
@@ -36,11 +44,16 @@ Aria2::Aria2():
   std::string rpc_secret = "--rpc-secret=" + m_secret;
   m_secret = "token:"+m_secret;
 
-#ifdef _WIN32
-  callCmd.push_back("aria2c.exe");
-#else
-  callCmd.push_back("aria2c");
-#endif
+  std::string aria2cmd = appendToDirectory(
+    removeLastPathElement(getExecutablePath(), true, true),
+    ARIA2_CMD);
+  if (fileExists(aria2cmd)) {
+    // A local aria2c exe exists (packaged with kiwix-desktop), use it.
+    callCmd.push_back(aria2cmd.c_str());
+  } else {
+    // Try to use a potential installed aria2c.
+    callCmd.push_back(ARIA2_CMD);
+  }
   callCmd.push_back("--enable-rpc");
   callCmd.push_back(rpc_secret.c_str());
   callCmd.push_back(rpc_port.c_str());
@@ -69,7 +82,7 @@ Aria2::Aria2():
 
   int watchdog = 50;
   while(--watchdog) {
-    std::this_thread::sleep_for(std::chrono::microseconds(100));
+    std::this_thread::sleep_for(std::chrono::microseconds(10000));
     auto res = curl_easy_perform(mp_curl);
     if (res == CURLE_OK) {
       break;

src/book.cpp

@@ -87,7 +87,7 @@ void Book::update(const kiwix::Reader& reader)
   m_origId = reader.getOrigId();
   m_articleCount = reader.getArticleCount();
   m_mediaCount = reader.getMediaCount();
-  m_size = reader.getFileSize() << 10;
+  m_size = static_cast<uint64_t>(reader.getFileSize()) << 10;
 
   reader.getFavicon(m_favicon, m_faviconMimeType);
 }
@@ -131,6 +131,14 @@ void Book::updateFromXml(const pugi::xml_node& node, const std::string& baseDir)
 #undef ATTR
 
 
+static std::string fromOpdsDate(const std::string& date)
+{
+  //The opds date use the standard <YYYY>-<MM>-<DD>T<HH>:<mm>:<SS>Z
+  //and we want <YYYY>-<MM>-<DD>. That's easy, let's take the first 10 char
+  return date.substr(0, 10);
+}
+
+
 #define VALUE(name) node.child(name).child_value()
 void Book::updateFromOpds(const pugi::xml_node& node, const std::string& urlHost)
 {
@@ -141,7 +149,7 @@ void Book::updateFromOpds(const pugi::xml_node& node, const std::string& urlHost
   m_title = VALUE("title");
   m_description = VALUE("description");
   m_language = VALUE("language");
-  m_date = VALUE("updated");
+  m_date = fromOpdsDate(VALUE("updated"));
   m_creator = node.child("author").child("name").child_value();
   for(auto linkNode = node.child("link"); linkNode;
            linkNode = linkNode.next_sibling("link")) {

src/bookmark.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "bookmark.h"
+
+#include <pugixml.hpp>
+
+namespace kiwix
+{
+/* Constructor */
+Bookmark::Bookmark()
+{
+}
+
+/* Destructor */
+Bookmark::~Bookmark()
+{
+}
+
+void Bookmark::updateFromXml(const pugi::xml_node& node)
+{
+  auto bookNode = node.child("book");
+  m_bookId = bookNode.child("id").child_value();
+  m_bookTitle = bookNode.child("title").child_value();
+  m_language = bookNode.child("language").child_value();
+  m_date = bookNode.child("date").child_value();
+  m_title = node.child("title").child_value();
+  m_url = node.child("url").child_value();
+}
+
+}

src/common/otherTools.cpp

@@ -20,252 +20,278 @@
 #include <common/otherTools.h>
 #include <map>
 
-std::map<std::string, std::string> codeisomapping {
-  { "af", "afg" },
-  { "ax", "ala" },
-  { "al", "alb" },
-  { "dz", "dza" },
-  { "as", "asm" },
+static std::map<std::string, std::string> codeisomapping {
+//a
   { "ad", "and" },
-  { "ao", "ago" },
-  { "ai", "aia" },
-  { "aq", "ata" },
+  { "ae", "are" },
+  { "af", "afg" },
   { "ag", "atg" },
-  { "ar", "arg" },
+  { "ai", "aia" },
+  { "al", "alb" },
   { "am", "arm" },
-  { "aw", "abw" },
-  { "au", "aus" },
+  { "an", "ant" },
+  { "ao", "ago" },
+  { "aq", "ata" },
+  { "ar", "arg" },
+  { "as", "asm" },
   { "at", "aut" },
+  { "au", "aus" },
+  { "aw", "abw" },
+  { "ax", "ala" },
   { "az", "aze" },
-  { "bs", "bhs" },
-  { "bh", "bhr" },
-  { "bd", "bgd" },
-  { "bb", "brb" },
-  { "by", "blr" },
-  { "be", "bel" },
-  { "bz", "blz" },
-  { "bj", "ben" },
-  { "bm", "bmu" },
-  { "bt", "btn" },
-  { "bo", "bol" },
+//b
   { "ba", "bih" },
-  { "bw", "bwa" },
-  { "bv", "bvt" },
-  { "br", "bra" },
-  { "vg", "vgb" },
-  { "io", "iot" },
-  { "bn", "brn" },
-  { "bg", "bgr" },
+  { "bb", "brb" },
+  { "bd", "bgd" },
+  { "be", "bel" },
   { "bf", "bfa" },
+  { "bg", "bgr" },
+  { "bh", "bhr" },
   { "bi", "bdi" },
-  { "kh", "khm" },
-  { "cm", "cmr" },
+  { "bj", "ben" },
+  { "bl", "blm" },
+  { "bn", "brn" },
+  { "bm", "bmu" },
+  { "bo", "bol" },
+  { "br", "bra" },
+  { "bs", "bhs" },
+  { "bt", "btn" },
+  { "bv", "bvt" },
+  { "bw", "bwa" },
+  { "by", "blr" },
+  { "bz", "blz" },
+//c
   { "ca", "can" },
-  { "cv", "cpv" },
-  { "ky", "cym" },
-  { "cf", "caf" },
-  { "td", "tcd" },
-  { "cl", "chl" },
-  { "cn", "chn" },
-  { "hk", "hkg" },
-  { "mo", "mac" },
-  { "cx", "cxr" },
   { "cc", "cck" },
-  { "co", "col" },
-  { "km", "com" },
-  { "cg", "cog" },
   { "cd", "cod" },
-  { "ck", "cok" },
-  { "cr", "cri" },
+  { "cf", "caf" },
+  { "cg", "cog" },
+  { "ch", "che" },
   { "ci", "civ" },
-  { "hr", "hrv" },
+  { "ck", "cok" },
+  { "cl", "chl" },
+  { "cm", "cmr" },
+  { "cn", "chn" },
+  { "co", "col" },
+  { "cr", "cri" },
   { "cu", "cub" },
+  { "cv", "cpv" },
+  { "cx", "cxr" },
   { "cy", "cyp" },
   { "cz", "cze" },
-  { "dk", "dnk" },
+//d
+  { "de", "deu" },
   { "dj", "dji" },
+  { "dk", "dnk" },
   { "dm", "dma" },
   { "do", "dom" },
+  { "dz", "dza" },
+//e
   { "ec", "ecu" },
-  { "eg", "egy" },
-  { "sv", "slv" },
-  { "gq", "gnq" },
-  { "er", "eri" },
   { "ee", "est" },
+  { "eg", "egy" },
+  { "eh", "esh" },
+  { "en", "eng" },
+  { "er", "eri" },
+  { "es", "esp" },
   { "et", "eth" },
-  { "fk", "flk" },
-  { "fo", "fro" },
-  { "fj", "fji" },
+//f
   { "fi", "fin" },
+  { "fj", "fji" },
+  { "fk", "flk" },
+  { "fm", "fsm" },
+  { "fo", "fro" },
   { "fr", "fra" },
-  { "gf", "guf" },
-  { "pf", "pyf" },
-  { "tf", "atf" },
+//g
   { "ga", "gab" },
-  { "gm", "gmb" },
+  { "gb", "gbr" },
+  { "gd", "grd" },
   { "ge", "geo" },
-  { "de", "deu" },
+  { "gf", "guf" },
+  { "gg", "ggy" },
   { "gh", "gha" },
   { "gi", "gib" },
-  { "gr", "grc" },
   { "gl", "grl" },
-  { "gd", "grd" },
-  { "gp", "glp" },
-  { "gu", "gum" },
-  { "gt", "gtm" },
-  { "gg", "ggy" },
+  { "gm", "gmb" },
   { "gn", "gin" },
+  { "gp", "glp" },
+  { "gq", "gnq" },
+  { "gr", "grc" },
+  { "gs", "sgs" },
+  { "gt", "gtm" },
+  { "gu", "gum" },
   { "gw", "gnb" },
   { "gy", "guy" },
-  { "ht", "hti" },
+//h
+  { "hk", "hkg" },
   { "hm", "hmd" },
-  { "va", "vat" },
   { "hn", "hnd" },
+  { "hr", "hrv" },
+  { "ht", "hti" },
   { "hu", "hun" },
-  { "is", "isl" },
-  { "in", "ind" },
+//i
   { "id", "idn" },
-  { "ir", "irn" },
-  { "iq", "irq" },
   { "ie", "irl" },
-  { "im", "imn" },
   { "il", "isr" },
+  { "im", "imn" },
+  { "in", "ind" },
+  { "io", "iot" },
+  { "iq", "irq" },
+  { "ir", "irn" },
+  { "is", "isl" },
   { "it", "ita" },
-  { "jm", "jam" },
-  { "jp", "jpn" },
+//j
   { "je", "jey" },
+  { "jm", "jam" },
   { "jo", "jor" },
-  { "kz", "kaz" },
+  { "jp", "jpn" },
+//k
   { "ke", "ken" },
+  { "kg", "kgz" },
+  { "kh", "khm" },
   { "ki", "kir" },
+  { "km", "com" },
+  { "kn", "kna" },
   { "kp", "prk" },
   { "kr", "kor" },
   { "kw", "kwt" },
-  { "kg", "kgz" },
+  { "ky", "cym" },
+  { "kz", "kaz" },
+//l
   { "la", "lao" },
-  { "lv", "lva" },
   { "lb", "lbn" },
-  { "ls", "lso" },
-  { "lr", "lbr" },
-  { "ly", "lby" },
+  { "lc", "lca" },
   { "li", "lie" },
+  { "lk", "lka" },
+  { "lr", "lbr" },
+  { "ls", "lso" },
   { "lt", "ltu" },
   { "lu", "lux" },
-  { "mk", "mkd" },
+  { "lv", "lva" },
+  { "ly", "lby" },
+//m
+  { "ma", "mar" },
+  { "mc", "mco" },
+  { "md", "mda" },
+  { "me", "mne" },
+  { "mf", "maf" },
   { "mg", "mdg" },
-  { "mw", "mwi" },
-  { "my", "mys" },
-  { "mv", "mdv" },
-  { "ml", "mli" },
-  { "mt", "mlt" },
   { "mh", "mhl" },
+  { "mk", "mkd" },
+  { "ml", "mli" },
+  { "mm", "mmr" },
+  { "mn", "mng" },
+  { "mo", "mac" },
+  { "mp", "mnp" },
   { "mq", "mtq" },
   { "mr", "mrt" },
-  { "mu", "mus" },
-  { "yt", "myt" },
-  { "mx", "mex" },
-  { "fm", "fsm" },
-  { "md", "mda" },
-  { "mc", "mco" },
-  { "mn", "mng" },
-  { "me", "mne" },
   { "ms", "msr" },
-  { "ma", "mar" },
+  { "mt", "mlt" },
+  { "mu", "mus" },
+  { "mv", "mdv" },
+  { "mw", "mwi" },
+  { "mx", "mex" },
+  { "my", "mys" },
   { "mz", "moz" },
-  { "mm", "mmr" },
+//n
   { "na", "nam" },
-  { "nr", "nru" },
-  { "np", "npl" },
-  { "nl", "nld" },
-  { "an", "ant" },
   { "nc", "ncl" },
-  { "nz", "nzl" },
-  { "ni", "nic" },
   { "ne", "ner" },
-  { "ng", "nga" },
-  { "nu", "niu" },
   { "nf", "nfk" },
-  { "mp", "mnp" },
+  { "ng", "nga" },
+  { "ni", "nic" },
+  { "nl", "nld" },
   { "no", "nor" },
+  { "np", "npl" },
+  { "nr", "nru" },
+  { "nu", "niu" },
+  { "nz", "nzl" },
+//o
   { "om", "omn" },
-  { "pk", "pak" },
-  { "pw", "plw" },
-  { "ps", "pse" },
+//p
   { "pa", "pan" },
-  { "pg", "png" },
-  { "py", "pry" },
   { "pe", "per" },
+  { "pf", "pyf" },
+  { "pg", "png" },
   { "ph", "phl" },
-  { "pn", "pcn" },
+  { "pk", "pak" },
   { "pl", "pol" },
-  { "pt", "prt" },
+  { "pm", "spm" },
+  { "pn", "pcn" },
   { "pr", "pri" },
+  { "ps", "pse" },
+  { "pt", "prt" },
+  { "pw", "plw" },
+  { "py", "pry" },
+//q
   { "qa", "qat" },
+//r
   { "re", "reu" },
   { "ro", "rou" },
+  { "rs", "srb" },
   { "ru", "rus" },
   { "rw", "rwa" },
-  { "bl", "blm" },
-  { "sh", "shn" },
-  { "kn", "kna" },
-  { "lc", "lca" },
-  { "mf", "maf" },
-  { "pm", "spm" },
-  { "vc", "vct" },
-  { "ws", "wsm" },
-  { "sm", "smr" },
-  { "st", "stp" },
+//s
   { "sa", "sau" },
-  { "sn", "sen" },
-  { "rs", "srb" },
-  { "sc", "syc" },
-  { "sl", "sle" },
-  { "sg", "sgp" },
-  { "sk", "svk" },
-  { "si", "svn" },
   { "sb", "slb" },
-  { "so", "som" },
-  { "za", "zaf" },
-  { "gs", "sgs" },
-  { "ss", "ssd" },
-  { "es", "esp" },
-  { "lk", "lka" },
+  { "sc", "syc" },
   { "sd", "sdn" },
-  { "sr", "sur" },
-  { "sj", "sjm" },
-  { "sz", "swz" },
   { "se", "swe" },
-  { "ch", "che" },
+  { "sg", "sgp" },
+  { "sh", "shn" },
+  { "si", "svn" },
+  { "sj", "sjm" },
+  { "sk", "svk" },
+  { "sl", "sle" },
+  { "sm", "smr" },
+  { "sn", "sen" },
+  { "so", "som" },
+  { "sr", "sur" },
+  { "ss", "ssd" },
+  { "st", "stp" },
+  { "sv", "slv" },
   { "sy", "syr" },
-  { "tw", "twn" },
-  { "tj", "tjk" },
-  { "tz", "tza" },
-  { "th", "tha" },
-  { "tl", "tls" },
-  { "tg", "tgo" },
-  { "tk", "tkl" },
-  { "to", "ton" },
-  { "tt", "tto" },
-  { "tn", "tun" },
-  { "tr", "tur" },
-  { "tm", "tkm" },
+  { "sz", "swz" },
+//t
   { "tc", "tca" },
+  { "td", "tcd" },
+  { "tf", "atf" },
+  { "tg", "tgo" },
+  { "th", "tha" },
+  { "tj", "tjk" },
+  { "tk", "tkl" },
+  { "tl", "tls" },
+  { "tm", "tkm" },
+  { "tn", "tun" },
+  { "to", "ton" },
+  { "tr", "tur" },
+  { "tt", "tto" },
   { "tv", "tuv" },
-  { "ug", "uga" },
+  { "tw", "twn" },
+  { "tz", "tza" },
+//u
   { "ua", "ukr" },
-  { "ae", "are" },
-  { "gb", "gbr" },
-  { "us", "usa" },
+  { "ug", "uga" },
   { "um", "umi" },
+  { "us", "usa" },
   { "uy", "ury" },
   { "uz", "uzb" },
-  { "vu", "vut" },
+//v
+  { "va", "vat" },
+  { "vc", "vct" },
   { "ve", "ven" },
-  { "vn", "vnm" },
+  { "vg", "vgb" },
   { "vi", "vir" },
+  { "vn", "vnm" },
+  { "vu", "vut" },
+//w
   { "wf", "wlf" },
-  { "eh", "esh" },
+  { "ws", "wsm" },
+//y
   { "ye", "yem" },
+  { "yt", "myt" },
+// z
+  { "za", "zaf" },
   { "zm", "zmb" },
   { "zw", "zwe" }
 };

src/common/pathTools.cpp

@@ -35,9 +35,9 @@
 #endif
 
 #ifdef _WIN32
-#define SEPARATOR "\\"
+const std::string SEPARATOR("\\");
 #else
-#define SEPARATOR "/"
+const std::string SEPARATOR("/");
 #include <unistd.h>
 #endif
 
@@ -66,9 +66,7 @@ string computeRelativePath(const string path, const string absolutePath)
   while (commonCount < pathParts.size()
          && commonCount < absolutePathParts.size()
          && pathParts[commonCount] == absolutePathParts[commonCount]) {
-    if (!pathParts[commonCount].empty()) {
       commonCount++;
-    }
   }
 
   string relativePath;
@@ -76,18 +74,17 @@ string computeRelativePath(const string path, const string absolutePath)
   /* On Windows you have a token more because the root is represented
      by a letter */
   if (commonCount == 0) {
-    relativePath = "../";
+    relativePath = ".." + SEPARATOR;
   }
 #endif
 
   for (unsigned int i = commonCount; i < pathParts.size(); i++) {
-    relativePath += "../";
+    relativePath += ".." + SEPARATOR;
   }
   for (unsigned int i = commonCount; i < absolutePathParts.size(); i++) {
     relativePath += absolutePathParts[i];
-    relativePath += i + 1 < absolutePathParts.size() ? "/" : "";
+    relativePath += i + 1 < absolutePathParts.size() ? SEPARATOR : "";
   }
-
   return relativePath;
 }
 

src/downloader.cpp

@@ -72,12 +72,12 @@ void Download::updateStatus(bool follow)
     } catch (InvalidRPCNode& e) { }
   }
   m_status = status;
-  m_totalLength = structNode.getMember("totalLength").getValue().getAsI();
-  m_completedLength = structNode.getMember("completedLength").getValue().getAsI();
-  m_downloadSpeed = structNode.getMember("downloadSpeed").getValue().getAsI();
+  m_totalLength = extractFromString<uint64_t>(structNode.getMember("totalLength").getValue().getAsS());
+  m_completedLength = extractFromString<uint64_t>(structNode.getMember("completedLength").getValue().getAsS());
+  m_downloadSpeed = extractFromString<uint64_t>(structNode.getMember("downloadSpeed").getValue().getAsS());
   try {
     auto verifiedLengthValue = structNode.getMember("verifiedLength").getValue();
-    m_verifiedLength = verifiedLengthValue.getAsI();
+    m_verifiedLength = extractFromString<uint64_t>(verifiedLengthValue.getAsS());
   } catch (InvalidRPCNode& e) { m_verifiedLength = 0; }
   auto filesMember = structNode.getMember("files");
   auto fileStruct = filesMember.getValue().getArray().getValue(0).getStruct();

src/library.cpp

@@ -19,6 +19,7 @@
 
 #include "library.h"
 #include "book.h"
+#include "libxml_dumper.h"
 
 #include "common/base64.h"
 #include "common/regexTools.h"
@@ -30,7 +31,7 @@
 namespace kiwix
 {
 /* Constructor */
-Library::Library() : version(KIWIX_LIBRARY_VERSION)
+Library::Library()
 {
 }
 /* Destructor */
@@ -43,31 +44,48 @@ bool Library::addBook(const Book& book)
 {
   /* Try to find it */
   try {
-    auto& oldbook = books.at(book.getId());
+    auto& oldbook = m_books.at(book.getId());
     oldbook.update(book);
     return false;
   } catch (std::out_of_range&) {
-    books[book.getId()] = book;
+    m_books[book.getId()] = book;
     return true;
   }
 }
 
+void Library::addBookmark(const Bookmark& bookmark)
+{
+  m_bookmarks.push_back(bookmark);
+}
+
+bool Library::removeBookmark(const std::string& zimId, const std::string& url)
+{
+  for(auto it=m_bookmarks.begin(); it!=m_bookmarks.end(); it++) {
+    if (it->getBookId() == zimId && it->getUrl() == url) {
+      m_bookmarks.erase(it);
+      return true;
+    }
+  }
+  return false;
+}
+
+
 
 bool Library::removeBookById(const std::string& id)
 {
-  return books.erase(id) == 1;
+  return m_books.erase(id) == 1;
 }
 
 Book& Library::getBookById(const std::string& id)
 {
-  return books.at(id);
+  return m_books.at(id);
 }
 
 unsigned int Library::getBookCount(const bool localBooks,
                                    const bool remoteBooks)
 {
   unsigned int result = 0;
-  for (auto& pair: books) {
+  for (auto& pair: m_books) {
     auto& book = pair.second;
     if ((!book.getPath().empty() && localBooks)
         || (book.getPath().empty() && remoteBooks)) {
@@ -78,91 +96,15 @@ unsigned int Library::getBookCount(const bool localBooks,
 }
 
 bool Library::writeToFile(const std::string& path) {
-  pugi::xml_document doc;
   auto baseDir = removeLastPathElement(path, true, false);
+  LibXMLDumper dumper(this);
+  dumper.setBaseDir(baseDir);
+  return writeTextFile(path, dumper.dumpLibXMLContent(getBooksIds()));
+}
 
-  /* Add the library node */
-  pugi::xml_node libraryNode = doc.append_child("library");
-
-  if (!version.empty())
-    libraryNode.append_attribute("version") = version.c_str();
-
-  /* Add each book */
-  for (auto& pair: books) {
-    auto& book = pair.second;
-    if (!book.readOnly()) {
-      pugi::xml_node bookNode = libraryNode.append_child("book");
-      bookNode.append_attribute("id") = book.getId().c_str();
-
-      if (!book.getPath().empty()) {
-        bookNode.append_attribute("path") = computeRelativePath(
-            baseDir, book.getPath()).c_str();
-      }
-
-      if (!book.getIndexPath().empty()) {
-        bookNode.append_attribute("indexPath") = computeRelativePath(
-            baseDir, book.getIndexPath()).c_str();
-        bookNode.append_attribute("indexType") = "xapian";
-      }
-
-      if (book.getOrigId().empty()) {
-        if (!book.getTitle().empty())
-          bookNode.append_attribute("title") = book.getTitle().c_str();
-
-        if (!book.getName().empty())
-          bookNode.append_attribute("name") = book.getName().c_str();
-
-        if (!book.getTags().empty())
-          bookNode.append_attribute("tags") = book.getTags().c_str();
-
-        if (!book.getDescription().empty())
-          bookNode.append_attribute("description") = book.getDescription().c_str();
-
-        if (!book.getLanguage().empty())
-          bookNode.append_attribute("language") = book.getLanguage().c_str();
-
-        if (!book.getCreator().empty())
-          bookNode.append_attribute("creator") = book.getCreator().c_str();
-
-        if (!book.getPublisher().empty())
-          bookNode.append_attribute("publisher") = book.getPublisher().c_str();
-
-        if (!book.getFavicon().empty())
-          bookNode.append_attribute("favicon") = base64_encode(book.getFavicon()).c_str();
-
-        if (!book.getFaviconMimeType().empty())
-          bookNode.append_attribute("faviconMimeType")
-              = book.getFaviconMimeType().c_str();
-      } else {
-        bookNode.append_attribute("origId") = book.getOrigId().c_str();
-      }
-
-      if (!book.getDate().empty()) {
-        bookNode.append_attribute("date") = book.getDate().c_str();
-      }
-
-      if (!book.getUrl().empty()) {
-        bookNode.append_attribute("url") = book.getUrl().c_str();
-      }
-
-      if (!book.getArticleCount())
-        bookNode.append_attribute("articleCount") = to_string(book.getArticleCount()).c_str();
-
-      if (!book.getMediaCount())
-        bookNode.append_attribute("mediaCount") = to_string(book.getMediaCount()).c_str();
-
-      if (book.getSize()) {
-        bookNode.append_attribute("size") = to_string(book.getSize()>>10).c_str();
-      }
-
-      if (!book.getDownloadId().empty()) {
-        bookNode.append_attribute("downloadId") = book.getDownloadId().c_str();
-      }
-    }
-  }
-
-  /* saving file */
-  return doc.save_file(path.c_str());
+bool Library::writeBookmarksToFile(const std::string& path) {
+  LibXMLDumper dumper(this);
+  return writeTextFile(path, dumper.dumpLibXMLBookmark());
 }
 
 std::vector<std::string> Library::getBooksLanguages()
@@ -170,7 +112,7 @@ std::vector<std::string> Library::getBooksLanguages()
   std::vector<std::string> booksLanguages;
   std::map<std::string, bool> booksLanguagesMap;
 
-  for (auto& pair: books) {
+  for (auto& pair: m_books) {
     auto& book = pair.second;
     auto& language = book.getLanguage();
     if (booksLanguagesMap.find(language) == booksLanguagesMap.end()) {
@@ -189,7 +131,7 @@ std::vector<std::string> Library::getBooksCreators()
   std::vector<std::string> booksCreators;
   std::map<std::string, bool> booksCreatorsMap;
 
-  for (auto& pair: books) {
+  for (auto& pair: m_books) {
     auto& book = pair.second;
     auto& creator = book.getCreator();
     if (booksCreatorsMap.find(creator) == booksCreatorsMap.end()) {
@@ -208,7 +150,7 @@ std::vector<std::string> Library::getBooksPublishers()
   std::vector<std::string> booksPublishers;
   std::map<std::string, bool> booksPublishersMap;
 
-  for (auto& pair:books) {
+  for (auto& pair:m_books) {
     auto& book = pair.second;
     auto& publisher = book.getPublisher();
     if (booksPublishersMap.find(publisher) == booksPublishersMap.end()) {
@@ -226,7 +168,7 @@ std::vector<std::string> Library::getBooksIds()
 {
   std::vector<std::string> bookIds;
 
-  for (auto& pair: books) {
+  for (auto& pair: m_books) {
     bookIds.push_back(pair.first);
   }
 
@@ -240,7 +182,7 @@ std::vector<std::string> Library::filter(const std::string& search)
   }
 
   std::vector<std::string> bookIds;
-  for(auto& pair:books) {
+  for(auto& pair:m_books) {
      auto& book = pair.second;
      if (matchRegex(book.getTitle(), "\\Q" + search + "\\E")
          || matchRegex(book.getDescription(), "\\Q" + search + "\\E")) {
@@ -311,7 +253,7 @@ std::vector<std::string> Library::listBooksIds(
     size_t maxSize) {
 
   std::vector<std::string> bookIds;
-  for(auto& pair:books) {
+  for(auto& pair:m_books) {
     auto& book = pair.second;
     auto local = !book.getPath().empty();
     if (mode & LOCAL && !local)

src/libxml_dumper.cpp

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2017 Matthieu Gautier <mgautier@kymeria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU  General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+#include "libxml_dumper.h"
+#include "book.h"
+
+#include <common/base64.h>
+#include <common/stringTools.h>
+#include <common/otherTools.h>
+
+namespace kiwix
+{
+/* Constructor */
+LibXMLDumper::LibXMLDumper(Library* library)
+  : library(library)
+{
+}
+/* Destructor */
+LibXMLDumper::~LibXMLDumper()
+{
+}
+
+#define ADD_ATTRIBUTE(node, name, value) { (node).append_attribute((name)) = (value).c_str(); }
+#define ADD_ATTR_NOT_EMPTY(node, name, value) { if (!(value).empty()) ADD_ATTRIBUTE(node, name, value); }
+
+void LibXMLDumper::handleBook(Book book, pugi::xml_node root_node) {
+  if (book.readOnly())
+    return;
+
+  auto entry_node = root_node.append_child("book");
+  ADD_ATTRIBUTE(entry_node, "id", book.getId());
+
+  if (!book.getPath().empty()) {
+    ADD_ATTRIBUTE(entry_node, "path", computeRelativePath(baseDir, book.getPath()));
+  }
+
+  if (!book.getIndexPath().empty()) {
+    ADD_ATTRIBUTE(entry_node, "indexPath", computeRelativePath(baseDir, book.getIndexPath()));
+    entry_node.append_attribute("indexType") = "xapian";
+  }
+
+  if (book.getOrigId().empty()) {
+    ADD_ATTR_NOT_EMPTY(entry_node, "title", book.getTitle());
+    ADD_ATTR_NOT_EMPTY(entry_node, "name", book.getName());
+    ADD_ATTR_NOT_EMPTY(entry_node, "tags", book.getTags());
+    ADD_ATTR_NOT_EMPTY(entry_node, "description", book.getDescription());
+    ADD_ATTR_NOT_EMPTY(entry_node, "language", book.getLanguage());
+    ADD_ATTR_NOT_EMPTY(entry_node, "creator", book.getCreator());
+    ADD_ATTR_NOT_EMPTY(entry_node, "publisher", book.getPublisher());
+    ADD_ATTR_NOT_EMPTY(entry_node, "faviconMimeType", book.getFaviconMimeType());
+    if (!book.getFavicon().empty())
+      ADD_ATTRIBUTE(entry_node, "favicon", base64_encode(book.getFavicon()));
+  } else {
+    ADD_ATTRIBUTE(entry_node, "origId", book.getOrigId());
+  }
+
+  ADD_ATTR_NOT_EMPTY(entry_node, "date", book.getDate());
+  ADD_ATTR_NOT_EMPTY(entry_node, "url", book.getUrl());
+
+  if (book.getArticleCount())
+    ADD_ATTRIBUTE(entry_node, "articleCount", to_string(book.getArticleCount()));
+
+  if (book.getMediaCount())
+    ADD_ATTRIBUTE(entry_node, "mediaCount", to_string(book.getMediaCount()));
+
+  if (book.getSize())
+    ADD_ATTRIBUTE(entry_node, "size", to_string(book.getSize()>>10));
+
+  ADD_ATTR_NOT_EMPTY(entry_node, "downloadId", book.getDownloadId());
+}
+
+#define ADD_TEXT_ENTRY(node, child, value) (node).append_child((child)).append_child(pugi::node_pcdata).set_value((value).c_str())
+
+void LibXMLDumper::handleBookmark(Bookmark bookmark, pugi::xml_node root_node) {
+
+  auto entry_node = root_node.append_child("bookmark");
+  auto book_node = entry_node.append_child("book");
+
+  try {
+    auto book = library->getBookById(bookmark.getBookId());
+    ADD_TEXT_ENTRY(book_node, "id", book.getId());
+    ADD_TEXT_ENTRY(book_node, "title", book.getTitle());
+    ADD_TEXT_ENTRY(book_node, "language", book.getLanguage());
+    ADD_TEXT_ENTRY(book_node, "date", book.getDate());
+  } catch (...) {
+    ADD_TEXT_ENTRY(book_node, "id", bookmark.getBookId());
+    ADD_TEXT_ENTRY(book_node, "title", bookmark.getBookTitle());
+    ADD_TEXT_ENTRY(book_node, "language", bookmark.getLanguage());
+    ADD_TEXT_ENTRY(book_node, "date", bookmark.getDate());
+  }
+  ADD_TEXT_ENTRY(entry_node, "title", bookmark.getTitle());
+  ADD_TEXT_ENTRY(entry_node, "url", bookmark.getUrl());
+}
+
+
+std::string LibXMLDumper::dumpLibXMLContent(const std::vector<std::string>& bookIds)
+{
+  pugi::xml_document doc;
+
+  /* Add the library node */
+  pugi::xml_node libraryNode = doc.append_child("library");
+
+  libraryNode.append_attribute("version") = KIWIX_LIBRARY_VERSION;
+
+  if (library) {
+    for (auto& bookId: bookIds) {
+      handleBook(library->getBookById(bookId), libraryNode);
+    }
+  }
+  return nodeToString(libraryNode);
+}
+
+std::string LibXMLDumper::dumpLibXMLBookmark()
+{
+  pugi::xml_document doc;
+
+  /* Add the library node */
+  pugi::xml_node bookmarksNode = doc.append_child("bookmarks");
+
+  if (library) {
+    for (auto& bookmark: library->getBookmarks()) {
+      handleBookmark(bookmark, bookmarksNode);
+    }
+  }
+  return nodeToString(bookmarksNode);
+}
+
+}

src/manager.cpp

@@ -95,6 +95,15 @@ bool Manager::parseOpdsDom(const pugi::xml_document& doc, const std::string& url
 {
   pugi::xml_node libraryNode = doc.child("feed");
 
+  try {
+    m_totalBooks = strtoull(libraryNode.child("totalResults").child_value(), 0, 0);
+    m_startIndex = strtoull(libraryNode.child("startIndex").child_value(), 0, 0);
+    m_itemsPerPage = strtoull(libraryNode.child("itemsPerPage").child_value(), 0, 0);
+    m_hasSearchResult = true;
+  } catch(...) {
+    m_hasSearchResult = false;
+  }
+
   for (pugi::xml_node entryNode = libraryNode.child("entry"); entryNode;
        entryNode = entryNode.next_sibling("entry")) {
     kiwix::Book book;
@@ -212,4 +221,27 @@ bool Manager::readBookFromPath(const std::string& path, kiwix::Book* book)
   return true;
 }
 
+bool Manager::readBookmarkFile(const std::string& path)
+{
+  pugi::xml_document doc;
+  pugi::xml_parse_result result = doc.load_file(path.c_str());
+
+  if (!result) {
+    return false;
+  }
+
+  pugi::xml_node libraryNode = doc.child("bookmarks");
+
+  for (pugi::xml_node node = libraryNode.child("bookmark"); node;
+       node = node.next_sibling("bookmark")) {
+    kiwix::Bookmark bookmark;
+
+    bookmark.updateFromXml(node);
+
+    manipulator->addBookmarkToLibrary(bookmark);
+  }
+
+  return true;
+}
+
 }

src/meson.build

@@ -1,7 +1,9 @@
 kiwix_sources = [
   'book.cpp',
+  'bookmark.cpp',
   'library.cpp',
   'manager.cpp',
+  'libxml_dumper.cpp',
   'opds_dumper.cpp',
   'downloader.cpp',
   'reader.cpp',

src/opds_dumper.cpp

@@ -50,6 +50,13 @@ std::string gen_date_str()
   return is.str();
 }
 
+static std::string gen_date_from_yyyy_mm_dd(const std::string& date)
+{
+  std::stringstream is;
+  is << date << "T00:00::00:Z";
+  return is.str();
+}
+
 void OPDSDumper::setOpenSearchInfo(int totalResults, int startIndex, int count)
 {
   m_totalResults = totalResults;
@@ -65,7 +72,7 @@ pugi::xml_node OPDSDumper::handleBook(Book book, pugi::xml_node root_node) {
   ADD_TEXT_ENTRY(entry_node, "title", book.getTitle());
   ADD_TEXT_ENTRY(entry_node, "id", "urn:uuid:"+book.getId());
   ADD_TEXT_ENTRY(entry_node, "icon", rootLocation + "/meta?name=favicon&content=" + book.getHumanReadableIdFromPath());
-  ADD_TEXT_ENTRY(entry_node, "updated", date);
+  ADD_TEXT_ENTRY(entry_node, "updated", gen_date_from_yyyy_mm_dd(book.getDate()));
   ADD_TEXT_ENTRY(entry_node, "summary", book.getDescription());
 
   auto content_node = entry_node.append_child("link");

src/reader.cpp

@@ -851,7 +851,7 @@ bool Reader::isCorrupted() const
 unsigned int Reader::getFileSize() const
 {
   zim::File* file = this->getZimFileHandler();
-  zim::offset_type size = 0;
+  zim::size_type size = 0;
 
   if (file != NULL) {
     size = file->getFilesize();