Upates for new release

Updated requirements for gdrive and gmail
Updated teststatus
2022-01-24 19:18:40 +01:00 · 2022-01-24 18:47:34 +01:00 · 2022-01-24 18:47:34 +01:00 · 2022-01-24 18:47:34 +01:00 · 2022-01-24 18:47:34 +01:00 · 2022-01-24 12:37:15 +01:00
875 changed files with 140766 additions and 108864 deletions
@@ -31,7 +31,7 @@ If applicable, add screenshots to help explain your problem.
 - OS: [e.g. Windows 10/Raspberry Pi OS]
 - Python version: [e.g. python2.7]
 - Calibre-Web version: [e.g. 0.6.8 or 087c4c59 (git rev-parse --short HEAD)]:
- - Docker container: [None/Technosoft2000/Linuxuser]:
+ - Docker container: [None/LinuxServer]:
 - Special Hardware: [e.g. Rasperry Pi Zero]
 - Browser: [e.g. Chrome 83.0.4103.97, Safari 13.3.7, Firefox 68.0.1 ESR]

@@ -0,0 +1 @@
+blank_issues_enabled: false
@@ -6,10 +6,12 @@ __pycache__/

 # Distribution / packaging
 .Python
+.python-version
 env/
 venv/
 eggs/
 dist/
+executable/
 build/
 vendor/
 .eggs/
@@ -29,4 +31,4 @@ vendor/
 settings.yaml
 gdrive_credentials
 client_secrets.json
-
+gmail.json
@@ -41,6 +41,6 @@ Open a new GitHub pull request with the patch. Ensure the PR description clearly

 In case your code enhances features of Calibre-Web: Create your pull request for the development branch if your enhancement consists of more than some lines of code in a local section of Calibre-Webs code. This makes it easier to test it and check all implication before it's made public.

-Please check if your code runs on Python 2.7 (still necessary in 2020) and mainly on python 3. If possible and the feature is related to operating system functions, try to check it on Windows and Linux.
-Calibre-Web is automatically tested on Linux in combination with python 3.7. The code for testing is in a [separate repo](https://github.com/OzzieIsaacs/calibre-web-test) on Github. It uses unit tests and performs real system tests with selenium; it would be great if you could consider also writing some tests.
+Please check if your code runs with python 3, python 2 is no longer supported. If possible and the feature is related to operating system functions, try to check it on Windows and Linux.
+Calibre-Web is automatically tested on Linux in combination with python 3.8. The code for testing is in a [separate repo](https://github.com/OzzieIsaacs/calibre-web-test) on Github. It uses unit tests and performs real system tests with selenium; it would be great if you could consider also writing some tests.
 A static code analysis is done by Codacy, but it's partly broken and doesn't run automatically. You could check your code with ESLint before contributing, a configuration file can be found in the projects root folder.
@@ -2,6 +2,13 @@

 Calibre-Web is a web app providing a clean interface for browsing, reading and downloading eBooks using an existing [Calibre](https://calibre-ebook.com) database.

+[![GitHub License](https://img.shields.io/github/license/janeczku/calibre-web?style=flat-square)](https://github.com/janeczku/calibre-web/blob/master/LICENSE)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/w/janeczku/calibre-web?logo=github&style=flat-square&label=commits)]()
+[![GitHub all releases](https://img.shields.io/github/downloads/janeczku/calibre-web/total?logo=github&style=flat-square)](https://github.com/janeczku/calibre-web/releases)
+[![PyPI](https://img.shields.io/pypi/v/calibreweb?logo=pypi&logoColor=fff&style=flat-square)](https://pypi.org/project/calibreweb/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/calibreweb?logo=pypi&logoColor=fff&style=flat-square)](https://pypi.org/project/calibreweb/)
+[![Discord](https://img.shields.io/discord/838810113564344381?label=Discord&logo=discord&style=flat-square)](https://discord.gg/h2VsJ2NEfB)
+
 *This software is a fork of [library](https://github.com/mutschler/calibreserver) and licensed under the GPL v3 License.*

 ![Main screen](https://github.com/janeczku/calibre-web/wiki/images/main_screen.png)
@@ -12,7 +19,7 @@ Calibre-Web is a web app providing a clean interface for browsing, reading and d
 - full graphical setup
 - User management with fine-grained per-user permissions
 - Admin interface
- User Interface in czech, dutch, english, finnish, french, german, hungarian, italian, japanese, khmer, polish, russian, simplified chinese, spanish, swedish, turkish, ukrainian
+- User Interface in brazilian, czech, dutch, english, finnish, french, german, greek, hungarian, italian, japanese, khmer, korean, polish, russian, simplified and traditional chinese, spanish, swedish, turkish, ukrainian
 - OPDS feed for eBook reader apps 
 - Filter and search by titles, authors, tags, series and language
 - Create a custom book collection (shelves)
@@ -22,7 +29,7 @@ Calibre-Web is a web app providing a clean interface for browsing, reading and d
 - Support for public user registration
 - Send eBooks to Kindle devices with the click of a button
 - Sync your Kobo devices through Calibre-Web with your Calibre library
- Support for reading eBooks directly in the browser (.txt, .epub, .pdf, .cbr, .cbt, .cbz)
+- Support for reading eBooks directly in the browser (.txt, .epub, .pdf, .cbr, .cbt, .cbz, .djvu)
 - Upload new books in many formats, including audio formats (.mp3, .m4a, .m4b)
 - Support for Calibre Custom Columns
 - Ability to hide content based on categories and Custom Column content per user
@@ -30,42 +37,45 @@ Calibre-Web is a web app providing a clean interface for browsing, reading and d
 - "Magic Link" login to make it easy to log on eReaders
 - Login via LDAP, google/github oauth and via proxy authentication

+## Installation
+
+#### Installation via pip (recommended)
+1. Install calibre web via pip with the command `pip install calibreweb` (Depending on your OS and or distro the command could also be `pip3`). 
+2. Optional features can also be installed via pip, please refer to [this page](https://github.com/janeczku/calibre-web/wiki/Dependencies-in-Calibre-Web-Linux-Windows) for details 
+3. Calibre-Web can be started afterwards by typing `cps` or `python3 -m cps` 
+
+#### Manual installation
+1. Install dependencies by running `pip3 install --target vendor -r requirements.txt` (python3.x). Alternativly set up a python virtual environment.
+2. Execute the command: `python3 cps.py` (or `nohup python3 cps.py` - recommended if you want to exit the terminal window)
+
+Issues with Ubuntu:
+Please note that running the above install command can fail on some versions of Ubuntu, saying `"can't combine user with prefix"`. This is a [known bug](https://github.com/pypa/pip/issues/3826) and can be remedied by using the command `pip install --system --target vendor -r requirements.txt` instead.
+
 ## Quick start

-1. Install dependencies by running `pip3 install --target vendor -r requirements.txt` (python3.x) or `pip install --target vendor -r requirements.txt` (python2.7).
-2. Execute the command: `python cps.py` (or `nohup python cps.py` - recommended if you want to exit the terminal window)
-3. Point your browser to `http://localhost:8083` or `http://localhost:8083/opds` for the OPDS catalog
-4. Set `Location of Calibre database` to the path of the folder where your Calibre library (metadata.db) lives, push "submit" button\
-   Optionally a Google Drive can be used to host the calibre library [-> Using Google Drive integration](https://github.com/janeczku/calibre-web/wiki/Configuration#using-google-drive-integration)
-5. Go to Login page
+Point your browser to `http://localhost:8083` or `http://localhost:8083/opds` for the OPDS catalog
+Set `Location of Calibre database` to the path of the folder where your Calibre library (metadata.db) lives, push "submit" button\
+Optionally a Google Drive can be used to host the calibre library [-> Using Google Drive integration](https://github.com/janeczku/calibre-web/wiki/Configuration#using-google-drive-integration)
+Go to Login page

-**Default admin login:**\
+#### Default admin login:
 *Username:* admin\
 *Password:* admin123

-**Issues with Ubuntu:**
-Please note that running the above install command can fail on some versions of Ubuntu, saying `"can't combine user with prefix"`. This is a [known bug](https://github.com/pypa/pip/issues/3826) and can be remedied by using the command `pip install --system --target vendor -r requirements.txt` instead.

 ## Requirements

-python 3.x+, (Python 2.7+)
+python 3.5+

 Optionally, to enable on-the-fly conversion from one ebook format to another when using the send-to-kindle feature, or during editing of ebooks metadata:

 [Download and install](https://calibre-ebook.com/download) the Calibre desktop program for your platform and enter the folder including program name (normally /opt/calibre/ebook-convert, or C:\Program Files\calibre\ebook-convert.exe) in the field "calibre's converter tool" on the setup page.

-[Download](https://github.com/geek1011/kepubify/releases/tag/v3.1.2) Kepubify tool for your platform and place the binary starting with `kepubify` in Linux: `\opt\kepubify` Windows: `C:\Program Files\kepubify`.
+[Download](https://github.com/pgaskin/kepubify/releases/latest) Kepubify tool for your platform and place the binary starting with `kepubify` in Linux: `\opt\kepubify` Windows: `C:\Program Files\kepubify`.

 ## Docker Images

-Pre-built Docker images are available in these Docker Hub repositories:
-
-#### **Technosoft2000 - x64**
-+ Docker Hub - [https://hub.docker.com/r/technosoft2000/calibre-web](https://hub.docker.com/r/technosoft2000/calibre-web)
-+ Github - [https://github.com/Technosoft2000/docker-calibre-web](https://github.com/Technosoft2000/docker-calibre-web) 
-
-    Includes the Calibre `ebook-convert` binary.
-    + The "path to convertertool" should be set to `/opt/calibre/ebook-convert`
+A pre-built Docker image is available in these Docker Hub repository (maintained by the LinuxServer team):

 #### **LinuxServer - x64, armhf, aarch64**
 + Docker Hub - [https://hub.docker.com/r/linuxserver/calibre-web](https://hub.docker.com/r/linuxserver/calibre-web)
@@ -80,7 +90,9 @@ Pre-built Docker images are available in these Docker Hub repositories:
   + The "path to convertertool" should be set to `/usr/bin/ebook-convert`
   + The "path to unrar" should be set to `/usr/bin/unrar`

-# Wiki
+# Contact
+
+Just reach us out on [Discord](https://discord.gg/h2VsJ2NEfB)

 For further information, How To's and FAQ please check the [Wiki](https://github.com/janeczku/calibre-web/wiki)

@@ -0,0 +1,39 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to ozzie.fernandez.isaacs@googlemail.com
+
+## Supported Versions
+
+To receive fixes for security vulnerabilities it is required to always upgrade to the latest version of Calibre-Web. See https://github.com/janeczku/calibre-web/releases/latest for the latest release.
+
+## History
+
+| Fixed in      | Description                                                                                                        |CVE number |
+|---------------|--------------------------------------------------------------------------------------------------------------------|---------|
+| 3rd July 2018 | Guest access acts as a backdoor                                                                                    ||
+| V 0.6.7       | Hardcoded secret key for sessions                                                                                  |CVE-2020-12627 |
+| V 0.6.13      | Calibre-Web Metadata cross site scripting                                                                          |CVE-2021-25964|
+| V 0.6.13      | Name of Shelves are only visible to users who can access the corresponding shelf Thanks to @ibarrionuevo           ||
+| V 0.6.13      | JavaScript could get executed in the description field. Thanks to @ranjit-git  and Hagai Wechsler (WhiteSource)    ||
+| V 0.6.13      | JavaScript could get executed in a custom column of type "comment" field                                           ||
+| V 0.6.13      | JavaScript could get executed after converting a book to another format with a title containing javascript code    ||
+| V 0.6.13      | JavaScript could get executed after converting a book to another format with a username containing javascript code ||
+| V 0.6.13      | JavaScript could get executed in the description series, categories or publishers title                            ||
+| V 0.6.13      | JavaScript could get executed  in the shelf title                                                                  ||
+| V 0.6.13      | Login with the old session cookie after logout. Thanks to @ibarrionuevo                                            ||
+| V 0.6.14      | CSRF was possible. Thanks to @mik317 and Hagai Wechsler (WhiteSource)                                              |CVE-2021-25965|
+| V 0.6.14      | Migrated some routes to POST-requests (CSRF protection). Thanks to @scara31                                        ||
+| V 0.6.15      | Fix for "javascript:" script links in identifier. Thanks to @scara31                                               ||
+| V 0.6.15      | Cross-Site Scripting vulnerability on uploaded cover file names. Thanks to @ibarrionuevo                           ||
+| V 0.6.15      | Creating public shelfs is now denied if user is missing the edit public shelf right. Thanks to @ibarrionuevo       ||
+| V 0.6.15      | Changed error message in case of trying to delete a shelf unauthorized. Thanks to @ibarrionuevo                    ||
+| V 0.6.16      | JavaScript could get executed on authors page. Thanks to @alicaz                                                   ||
+| V 0.6.16      | Localhost can no longer be used to upload covers. Thanks to @scara31                                               ||
+| V 0.6.16      | Another case where public shelfs could be created without permission is prevented. Thanks to @ibarrionuevo         ||
+
+
+## Staement regarding Log4j (CVE-2021-44228 and related)
+
+Calibre-web is not affected by bugs related to Log4j. Calibre-Web is a python program, therefore not using Java, and not using the Java logging feature log4j. 
@@ -17,18 +17,13 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import absolute_import, division, print_function, unicode_literals
 import sys
 import os


 # Insert local directories into path
-if sys.version_info < (3, 0):
-    sys.path.append(os.path.dirname(os.path.abspath(__file__.decode('utf-8'))))
-    sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__.decode('utf-8'))), 'vendor'))
-else:
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-    sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'vendor'))
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'vendor'))


 from cps import create_app
@@ -41,12 +36,15 @@ from cps.shelf import shelf
 from cps.admin import admi
 from cps.gdrive import gdrive
 from cps.editbooks import editbook
+from cps.remotelogin import remotelogin
+from cps.search_metadata import meta
+from cps.error_handler import init_errorhandler

 try:
    from cps.kobo import kobo, get_kobo_activated
    from cps.kobo_auth import kobo_auth
    kobo_available = get_kobo_activated()
-except ImportError:
+except (ImportError, AttributeError):   # Catch also error for not installed flask-WTF (missing csrf decorator)
    kobo_available = False

 try:
@@ -58,12 +56,17 @@ except ImportError:

 def main():
    app = create_app()
+
+    init_errorhandler()
+
    app.register_blueprint(web)
    app.register_blueprint(opds)
    app.register_blueprint(jinjia)
    app.register_blueprint(about)
    app.register_blueprint(shelf)
    app.register_blueprint(admi)
+    app.register_blueprint(remotelogin)
+    app.register_blueprint(meta)
    app.register_blueprint(gdrive)
    app.register_blueprint(editbook)
    if kobo_available:
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2018-2019 OzzieIsaacs, cervinko, jkrehm, bodybybuddha, ok11,
+#                            andy29485, idalin, Kyosfonica, wuqi, Kennyl, lemmsh,
+#                            falgh1, grunjol, csitko, ytils, xybydy, trasba, vrabe,
+#                            ruben-herold, marblepebble, JackED42, SiphonSquirrel,
+#                            apetresc, nanu-c, mutschler, GammaC0de, vuolter
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+
+from flask_login import LoginManager
+from flask import session
+
+
+class MyLoginManager(LoginManager):
+    def _session_protection_failed(self):
+        sess = session._get_current_object()
+        ident = self._session_identifier_generator()
+        if(sess and not (len(sess) == 1 and sess.get('csrf_token', None))) and ident != sess.get('_id', None):
+            return super(). _session_protection_failed()
+        return False
@@ -19,8 +19,8 @@
 #
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.
+__package__ = "cps"

-from __future__ import division, print_function, unicode_literals
 import sys
 import os
 import mimetypes
@@ -29,14 +29,26 @@ from babel import Locale as LC
 from babel import negotiate_locale
 from babel.core import UnknownLocaleError
 from flask import Flask, request, g
-from flask_login import LoginManager
+from .MyLoginManager import MyLoginManager
 from flask_babel import Babel
 from flask_principal import Principal

 from . import config_sql, logger, cache_buster, cli, ub, db
 from .reverseproxy import ReverseProxied
 from .server import WebServer
+from .dep_check import dependency_check

+try:
+    import lxml
+    lxml_present = True
+except ImportError:
+    lxml_present = False
+
+try:
+    from flask_wtf.csrf import CSRFProtect
+    wtf_present = True
+except ImportError:
+    wtf_present = False

 mimetypes.init()
 mimetypes.add_type('application/xhtml+xml', '.xhtml')
@@ -45,6 +57,7 @@ mimetypes.add_type('application/fb2+zip', '.fb2')
 mimetypes.add_type('application/x-mobipocket-ebook', '.mobi')
 mimetypes.add_type('application/x-mobipocket-ebook', '.prc')
 mimetypes.add_type('application/vnd.amazon.ebook', '.azw')
+mimetypes.add_type('application/x-mobi8-ebook', '.azw3')
 mimetypes.add_type('application/x-cbr', '.cbr')
 mimetypes.add_type('application/x-cbz', '.cbz')
 mimetypes.add_type('application/x-cbt', '.cbt')
@@ -55,25 +68,33 @@ mimetypes.add_type('application/mp4', '.m4a')
 mimetypes.add_type('application/mp4', '.m4b')
 mimetypes.add_type('application/ogg', '.ogg')
 mimetypes.add_type('application/ogg', '.oga')
+mimetypes.add_type('text/css', '.css')
+mimetypes.add_type('text/javascript; charset=UTF-8', '.js')

 app = Flask(__name__)
 app.config.update(
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE='Lax',
    REMEMBER_COOKIE_SAMESITE='Lax',  # will be available in flask-login 0.5.1 earliest
+    WTF_CSRF_SSL_STRICT=False
 )


-lm = LoginManager()
+lm = MyLoginManager()
 lm.login_view = 'web.login'
 lm.anonymous_user = ub.Anonymous
 lm.session_protection = 'strong'

+if wtf_present:
+    csrf = CSRFProtect()
+    csrf.init_app(app)
+else:
+    csrf = None
+
 ub.init_db(cli.settingspath)
 # pylint: disable=no-member
 config = config_sql.load_configuration(ub.session)

-searched_ids = {}
 web_server = WebServer()

 babel = Babel()
@@ -81,28 +102,49 @@ _BABEL_TRANSLATIONS = set()

 log = logger.create()

+
 from . import services

+db.CalibreDB.update_config(config)
+db.CalibreDB.setup_db(config.config_calibre_dir, cli.settingspath)
+
+
 calibre_db = db.CalibreDB()

 def create_app():
-    app.wsgi_app = ReverseProxied(app.wsgi_app)
-    # For python2 convert path to unicode
    if sys.version_info < (3, 0):
-        app.static_folder = app.static_folder.decode('utf-8')
-        app.root_path = app.root_path.decode('utf-8')
-        app.instance_path = app.instance_path .decode('utf-8')
-
-    cache_buster.init_cache_busting(app)
+        log.info(
+            '*** Python2 is EOL since end of 2019, this version of Calibre-Web is no longer supporting Python2, please update your installation to Python3 ***')
+        print(
+            '*** Python2 is EOL since end of 2019, this version of Calibre-Web is no longer supporting Python2, please update your installation to Python3 ***')
+        web_server.stop(True)
+        sys.exit(5)
+    if not lxml_present:
+        log.info('*** "lxml" is needed for calibre-web to run. Please install it using pip: "pip install lxml" ***')
+        print('*** "lxml" is needed for calibre-web to run. Please install it using pip: "pip install lxml" ***')
+        web_server.stop(True)
+        sys.exit(6)
+    if not wtf_present:
+        log.info('*** "flask-WTF" is needed for calibre-web to run. Please install it using pip: "pip install flask-WTF" ***')
+        print('*** "flask-WTF" is needed for calibre-web to run. Please install it using pip: "pip install flask-WTF" ***')
+        web_server.stop(True)
+        sys.exit(7)
+    for res in dependency_check() + dependency_check(True):
+        log.info('*** "{}" version does not fit the requirements. Should: {}, Found: {}, please consider installing required version ***'
+            .format(res['name'],
+                 res['target'],
+                 res['found']))
+    app.wsgi_app = ReverseProxied(app.wsgi_app)

+    if os.environ.get('FLASK_DEBUG'):
+        cache_buster.init_cache_busting(app)
    log.info('Starting Calibre Web...')
+
    Principal(app)
    lm.init_app(app)
    app.secret_key = os.getenv('SECRET_KEY', config_sql.get_flask_session_key(ub.session))

    web_server.init_app(app, config)
-    calibre_db.setup_db(config, cli.settingspath)
-    calibre_db.start()

    babel.init_app(app)
    _BABEL_TRANSLATIONS.update(str(item) for item in babel.list_translations())
@@ -121,9 +163,8 @@ def create_app():
 def get_locale():
    # if a user is logged in, use the locale from the user settings
    user = getattr(g, 'user', None)
-    # user = None
    if user is not None and hasattr(user, "locale"):
-        if user.nickname != 'Guest':   # if the account is the guest account bypass the config lang settings
+        if user.name != 'Guest':   # if the account is the guest account bypass the config lang settings
            return user.locale

    preferred = list()
@@ -142,6 +183,7 @@ def get_timezone():
    user = getattr(g, 'user', None)
    return user.timezone if user else None

+
 from .updater import Updater
 updater_thread = Updater()
 updater_thread.start()
@@ -20,7 +20,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import sys
 import platform
 import sqlite3
@@ -29,14 +28,20 @@ from collections import OrderedDict
 import babel, pytz, requests, sqlalchemy
 import werkzeug, flask, flask_login, flask_principal, jinja2
 from flask_babel import gettext as _
+try:
+    from flask_wtf import __version__ as flaskwtf_version
+except ImportError:
+    flaskwtf_version = _(u'not installed')
+
+from . import db, calibre_db, converter, uploader, server, isoLanguages, constants, gdriveutils, dep_check
+from .render_template import render_title_template

-from . import db, calibre_db, converter, uploader, server, isoLanguages, constants
-from .web import render_title_template
 try:
    from flask_login import __version__ as flask_loginVersion
 except ImportError:
    from flask_login.__about__ import __version__ as flask_loginVersion
 try:
+    # pylint: disable=unused-import
    import unidecode
    # _() necessary to make babel aware of string for translation
    unidecode_version = _(u'installed')
@@ -48,39 +53,86 @@ try:
 except ImportError:
    flask_danceVersion = None

+try:
+    from greenlet import __version__ as greenlet_Version
+except ImportError:
+    greenlet_Version = None
+
+try:
+    from scholarly import scholarly
+    scholarly_version = _(u'installed')
+except ImportError:
+    scholarly_version = _(u'not installed')
+
 from . import services

 about = flask.Blueprint('about', __name__)

+ret = dict()
+req = dep_check.load_dependencys(False)
+opt = dep_check.load_dependencys(True)
+for i in (req + opt):
+    ret[i[1]] = i[0]

-_VERSIONS = OrderedDict(
-    Platform = '{0[0]} {0[2]} {0[3]} {0[4]} {0[5]}'.format(platform.uname()),
-    Python=sys.version,
-    Calibre_Web=constants.STABLE_VERSION['version'] + ' - '
-                + constants.NIGHTLY_VERSION[0].replace('%','%%') + ' - '
-                + constants.NIGHTLY_VERSION[1].replace('%','%%'),
-    WebServer=server.VERSION,
-    Flask=flask.__version__,
-    Flask_Login=flask_loginVersion,
-    Flask_Principal=flask_principal.__version__,
-    Werkzeug=werkzeug.__version__,
-    Babel=babel.__version__,
-    Jinja2=jinja2.__version__,
-    Requests=requests.__version__,
-    SqlAlchemy=sqlalchemy.__version__,
-    pySqlite=sqlite3.version,
-    SQLite=sqlite3.sqlite_version,
-    iso639=isoLanguages.__version__,
-    pytz=pytz.__version__,
-    Unidecode = unidecode_version,
-    Flask_SimpleLDAP =  u'installed' if bool(services.ldap) else None,
-    python_LDAP = services.ldapVersion if bool(services.ldapVersion) else None,
-    Goodreads = u'installed' if bool(services.goodreads_support) else None,
-    jsonschema = services.SyncToken.__version__  if bool(services.SyncToken) else None,
-    flask_dance = flask_danceVersion
-)
-_VERSIONS.update(uploader.get_versions())
+if constants.NIGHTLY_VERSION[0] == "$Format:%H$":
+    calibre_web_version = constants.STABLE_VERSION['version']
+else:
+    calibre_web_version = (constants.STABLE_VERSION['version'] + ' - '
+                    + constants.NIGHTLY_VERSION[0].replace('%','%%') + ' - '
+                    + constants.NIGHTLY_VERSION[1].replace('%','%%'))
+if getattr(sys, 'frozen', False):
+    calibre_web_version += " - Exe-Version"
+elif constants.HOME_CONFIG:
+    calibre_web_version += " - pyPi"

+if not ret:
+    _VERSIONS = OrderedDict(
+        Platform = '{0[0]} {0[2]} {0[3]} {0[4]} {0[5]}'.format(platform.uname()),
+        Python=sys.version,
+        Calibre_Web=calibre_web_version,
+        WebServer=server.VERSION,
+        Flask=flask.__version__,
+        Flask_Login=flask_loginVersion,
+        Flask_Principal=flask_principal.__version__,
+        Flask_WTF=flaskwtf_version,
+        Werkzeug=werkzeug.__version__,
+        Babel=babel.__version__,
+        Jinja2=jinja2.__version__,
+        Requests=requests.__version__,
+        SqlAlchemy=sqlalchemy.__version__,
+        pySqlite=sqlite3.version,
+        SQLite=sqlite3.sqlite_version,
+        iso639=isoLanguages.__version__,
+        pytz=pytz.__version__,
+        Unidecode=unidecode_version,
+        Scholarly=scholarly_version,
+        Flask_SimpleLDAP=u'installed' if bool(services.ldap) else None,
+        python_LDAP=services.ldapVersion if bool(services.ldapVersion) else None,
+        Goodreads=u'installed' if bool(services.goodreads_support) else None,
+        jsonschema=services.SyncToken.__version__ if bool(services.SyncToken) else None,
+        flask_dance=flask_danceVersion,
+        greenlet=greenlet_Version
+    )
+    _VERSIONS.update(gdriveutils.get_versions())
+    _VERSIONS.update(uploader.get_versions(True))
+else:
+    _VERSIONS = OrderedDict(
+        Platform = '{0[0]} {0[2]} {0[3]} {0[4]} {0[5]}'.format(platform.uname()),
+        Python = sys.version,
+        Calibre_Web=calibre_web_version,
+        Werkzeug = werkzeug.__version__,
+        Jinja2=jinja2.__version__,
+        pySqlite = sqlite3.version,
+        SQLite = sqlite3.sqlite_version,
+    )
+    _VERSIONS.update(ret)
+    _VERSIONS.update(uploader.get_versions(False))
+
+def collect_stats():
+    _VERSIONS['ebook converter'] = _(converter.get_calibre_version())
+    _VERSIONS['unrar'] = _(converter.get_unrar_version())
+    _VERSIONS['kepubify'] = _(converter.get_kepubify_version())
+    return _VERSIONS

@about.route("/stats")
@flask_login.login_required
@@ -89,8 +141,5 @@ def stats():
    authors = calibre_db.session.query(db.Authors).count()
    categorys = calibre_db.session.query(db.Tags).count()
    series = calibre_db.session.query(db.Series).count()
-    _VERSIONS['ebook converter'] = _(converter.get_calibre_version())
-    _VERSIONS['unrar'] = _(converter.get_unrar_version())
-    _VERSIONS['kepubify'] = _(converter.get_kepubify_version())
-    return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, versions=_VERSIONS,
+    return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, versions=collect_stats(),
                                 categorycounter=categorys, seriecounter=series, title=_(u"Statistics"), page="stat")
@@ -19,7 +19,6 @@
 # Inspired by https://github.com/ChrisTM/Flask-CacheBust
 # Uses query strings so CSS font files are found without having to resort to absolute URLs

-from __future__ import division, print_function, unicode_literals
 import os
 import hashlib

@@ -49,7 +48,7 @@ def init_cache_busting(app):
            # compute version component
            rooted_filename = os.path.join(dirpath, filename)
            with open(rooted_filename, 'rb') as f:
-                file_hash = hashlib.md5(f.read()).hexdigest()[:7]
+                file_hash = hashlib.md5(f.read()).hexdigest()[:7] # nosec

            # save version to tables
            file_path = rooted_filename.replace(static_folder, "")
@@ -64,6 +63,7 @@ def init_cache_busting(app):
        return filename.split("?", 1)[0]

    @app.url_defaults
+    # pylint: disable=unused-variable
    def reverse_to_cache_busted_url(endpoint, values):
        """
        Make `url_for` produce busted filenames when using the 'static' endpoint.
@@ -16,7 +16,6 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import sys
 import os
 import argparse
@@ -45,21 +44,10 @@ parser.add_argument('-v', '--version', action='version', help='Shows version num
                    version=version_info())
 parser.add_argument('-i', metavar='ip-address', help='Server IP-Address to listen')
 parser.add_argument('-s', metavar='user:pass', help='Sets specific username to new password')
+parser.add_argument('-f', action='store_true', help='Flag is depreciated and will be removed in next version')
+parser.add_argument('-l', action='store_true', help='Allow loading covers from localhost')
 args = parser.parse_args()

-if sys.version_info < (3, 0):
-    if args.p:
-        args.p = args.p.decode('utf-8')
-    if args.g:
-        args.g = args.g.decode('utf-8')
-    if args.k:
-        args.k = args.k.decode('utf-8')
-    if args.c:
-        args.c = args.c.decode('utf-8')
-    if args.s:
-        args.s = args.s.decode('utf-8')
-
-
 settingspath = args.p or os.path.join(_CONFIG_DIR, "app.db")
 gdpath       = args.g or os.path.join(_CONFIG_DIR, "gdrive.db")

@@ -70,7 +58,7 @@ if args.c:
    if os.path.isfile(args.c):
        certfilepath = args.c
    else:
-        print("Certfilepath is invalid. Exiting...")
+        print("Certfile path is invalid. Exiting...")
        sys.exit(1)

 if args.c == "":
@@ -80,7 +68,7 @@ if args.k:
    if os.path.isfile(args.k):
        keyfilepath = args.k
    else:
-        print("Keyfilepath is invalid. Exiting...")
+        print("Keyfile path is invalid. Exiting...")
        sys.exit(1)

 if (args.k and not args.c) or (not args.k and args.c):
@@ -90,23 +78,31 @@ if (args.k and not args.c) or (not args.k and args.c):
 if args.k == "":
    keyfilepath = ""

-# handle and check ipadress argument
-ipadress = args.i or None
-if ipadress:
+# load covers from localhost
+allow_localhost = args.l or None
+# handle and check ip address argument
+ip_address = args.i or None
+if ip_address:
    try:
        # try to parse the given ip address with socket
        if hasattr(socket, 'inet_pton'):
-            if ':' in ipadress:
-                socket.inet_pton(socket.AF_INET6, ipadress)
+            if ':' in ip_address:
+                socket.inet_pton(socket.AF_INET6, ip_address)
            else:
-                socket.inet_pton(socket.AF_INET, ipadress)
+                socket.inet_pton(socket.AF_INET, ip_address)
        else:
            # on windows python < 3.4, inet_pton is not available
            # inet_atom only handles IPv4 addresses
-            socket.inet_aton(ipadress)
+            socket.inet_aton(ip_address)
    except socket.error as err:
-        print(ipadress, ':', err)
+        print(ip_address, ':', err)
        sys.exit(1)

 # handle and check user password argument
-user_password = args.s or None
+user_credentials = args.s or None
+if user_credentials and ":" not in user_credentials:
+    print("No valid 'username:password' format")
+    sys.exit(3)
+
+if args.f:
+    print("Warning: -f flag is depreciated and will be removed in next version")
@@ -16,29 +16,28 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
-import io

 from . import logger, isoLanguages
 from .constants import BookMeta

-try:
-    from PIL import Image as PILImage
-    use_PIL = True
-except ImportError as e:
-    use_PIL = False
-

 log = logger.create()


+try:
+    from wand.image import Image
+    use_IM = True
+except (ImportError, RuntimeError) as e:
+    use_IM = False
+
+
 try:
    from comicapi.comicarchive import ComicArchive, MetaDataStyle
    use_comic_meta = True
    try:
        from comicapi import __version__ as comic_version
-    except (ImportError):
+    except ImportError:
        comic_version = ''
 except (ImportError, LookupError) as e:
    log.debug('Cannot import comicapi, extracting comic metadata will not work: %s', e)
@@ -47,32 +46,68 @@ except (ImportError, LookupError) as e:
    try:
        import rarfile
        use_rarfile = True
-    except ImportError as e:
+    except (ImportError, SyntaxError) as e:
        log.debug('Cannot import rarfile, extracting cover files from rar files will not work: %s', e)
        use_rarfile = False
    use_comic_meta = False

+NO_JPEG_EXTENSIONS = ['.png', '.webp', '.bmp']
+COVER_EXTENSIONS = ['.png', '.webp', '.bmp', '.jpg', '.jpeg']
+
 def _cover_processing(tmp_file_name, img, extension):
-    if use_PIL:
-        # convert to jpg because calibre only supports jpg
-        if extension in ('.png',  '.webp'):
-            imgc = PILImage.open(io.BytesIO(img))
-            im = imgc.convert('RGB')
-            tmp_bytesio = io.BytesIO()
-            im.save(tmp_bytesio, format='JPEG')
-            img = tmp_bytesio.getvalue()
-
-    prefix = os.path.dirname(tmp_file_name)
+    tmp_cover_name = os.path.join(os.path.dirname(tmp_file_name), 'cover.jpg')
+    if extension in NO_JPEG_EXTENSIONS:
+        if use_IM:
+            with Image(blob=img) as imgc:
+                imgc.format = 'jpeg'
+                imgc.transform_colorspace('rgb')
+                imgc.save(filename=tmp_cover_name)
+                return tmp_cover_name
+        else:
+            return None
    if img:
-        tmp_cover_name = prefix + '/cover.jpg'
-        image = open(tmp_cover_name, 'wb')
-        image.write(img)
-        image.close()
+        with open(tmp_cover_name, 'wb') as f:
+            f.write(img)
+        return tmp_cover_name
    else:
-        tmp_cover_name = None
-    return tmp_cover_name
+        return None


+def _extract_Cover_from_archive(original_file_extension, tmp_file_name, rarExecutable):
+    cover_data = extension = None
+    if original_file_extension.upper() == '.CBZ':
+        cf = zipfile.ZipFile(tmp_file_name)
+        for name in cf.namelist():
+            ext = os.path.splitext(name)
+            if len(ext) > 1:
+                extension = ext[1].lower()
+                if extension in COVER_EXTENSIONS:
+                    cover_data = cf.read(name)
+                    break
+    elif original_file_extension.upper() == '.CBT':
+        cf = tarfile.TarFile(tmp_file_name)
+        for name in cf.getnames():
+            ext = os.path.splitext(name)
+            if len(ext) > 1:
+                extension = ext[1].lower()
+                if extension in COVER_EXTENSIONS:
+                    cover_data = cf.extractfile(name).read()
+                    break
+    elif original_file_extension.upper() == '.CBR' and use_rarfile:
+        try:
+            rarfile.UNRAR_TOOL = rarExecutable
+            cf = rarfile.RarFile(tmp_file_name)
+            for name in cf.getnames():
+                ext = os.path.splitext(name)
+                if len(ext) > 1:
+                    extension = ext[1].lower()
+                    if extension in COVER_EXTENSIONS:
+                        cover_data = cf.read(name)
+                        break
+        except Exception as ex:
+            log.debug('Rarfile failed with error: %s', ex)
+    return cover_data, extension
+

 def _extractCover(tmp_file_name, original_file_extension, rarExecutable):
    cover_data = extension = None
@@ -82,41 +117,11 @@ def _extractCover(tmp_file_name, original_file_extension, rarExecutable):
            ext = os.path.splitext(name)
            if len(ext) > 1:
                extension = ext[1].lower()
-                if extension in ('.jpg', '.jpeg', '.png', '.webp'):
+                if extension in COVER_EXTENSIONS:
                    cover_data = archive.getPage(index)
                    break
    else:
-        if original_file_extension.upper() == '.CBZ':
-            cf = zipfile.ZipFile(tmp_file_name)
-            for name in cf.namelist():
-                ext = os.path.splitext(name)
-                if len(ext) > 1:
-                    extension = ext[1].lower()
-                    if extension in ('.jpg', '.jpeg', '.png', '.webp'):
-                        cover_data = cf.read(name)
-                        break
-        elif original_file_extension.upper() == '.CBT':
-            cf = tarfile.TarFile(tmp_file_name)
-            for name in cf.getnames():
-                ext = os.path.splitext(name)
-                if len(ext) > 1:
-                    extension = ext[1].lower()
-                    if extension in ('.jpg', '.jpeg', '.png', '.webp'):
-                        cover_data = cf.extractfile(name).read()
-                        break
-        elif original_file_extension.upper() == '.CBR' and use_rarfile:
-            try:
-                rarfile.UNRAR_TOOL = rarExecutable
-                cf = rarfile.RarFile(tmp_file_name)
-                for name in cf.getnames():
-                    ext = os.path.splitext(name)
-                    if len(ext) > 1:
-                        extension = ext[1].lower()
-                        if extension in ('.jpg', '.jpeg', '.png', '.webp'):
-                            cover_data = cf.read(name)
-                            break
-            except Exception as e:
-                log.debug('Rarfile failed with error: %s', e)
+        cover_data, extension = _extract_Cover_from_archive(original_file_extension, tmp_file_name, rarExecutable)
    return _cover_processing(tmp_file_name, cover_data, extension)


@@ -141,13 +146,15 @@ def get_comic_info(tmp_file_path, original_file_name, original_file_extension, r
                file_path=tmp_file_path,
                extension=original_file_extension,
                title=loadedMetadata.title or original_file_name,
-                author=" & ".join([credit["person"] for credit in loadedMetadata.credits if credit["role"] == "Writer"]) or u'Unknown',
+                author=" & ".join([credit["person"]
+                                   for credit in loadedMetadata.credits if credit["role"] == "Writer"]) or u'Unknown',
                cover=_extractCover(tmp_file_path, original_file_extension, rarExecutable),
                description=loadedMetadata.comments or "",
                tags="",
                series=loadedMetadata.series or "",
                series_id=loadedMetadata.issue or "",
-                languages=loadedMetadata.language)
+                languages=loadedMetadata.language,
+                publisher="")

    return BookMeta(
        file_path=tmp_file_path,
@@ -159,4 +166,5 @@ def get_comic_info(tmp_file_path, original_file_name, original_file_extension, r
        tags="",
        series="",
        series_id="",
-        languages="")
+        languages="",
+        publisher="")
@@ -16,16 +16,20 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-
-from __future__ import division, print_function, unicode_literals
 import os
-import json
 import sys
+import json

-from sqlalchemy import exc, Column, String, Integer, SmallInteger, Boolean, BLOB, JSON
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, String, Integer, SmallInteger, Boolean, BLOB, JSON
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.sql.expression import text
+try:
+    # Compatibility with sqlalchemy 2.0
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base

-from . import constants, cli, logger, ub
+from . import constants, cli, logger


 log = logger.create()
@@ -35,7 +39,7 @@ class _Flask_Settings(_Base):
    __tablename__ = 'flask_settings'

    id = Column(Integer, primary_key=True)
-    flask_session_key = Column(BLOB, default="")
+    flask_session_key = Column(BLOB, default=b"")

    def __init__(self, key):
        self.flask_session_key = key
@@ -54,19 +58,21 @@ class _Settings(_Base):
    mail_password = Column(String, default='mypassword')
    mail_from = Column(String, default='automailer <mail@example.com>')
    mail_size = Column(Integer, default=25*1024*1024)
+    mail_server_type = Column(SmallInteger, default=0)
+    mail_gmail_token = Column(JSON, default={})

    config_calibre_dir = Column(String)
    config_port = Column(Integer, default=constants.DEFAULT_PORT)
    config_external_port = Column(Integer, default=constants.DEFAULT_PORT)
    config_certfile = Column(String)
    config_keyfile = Column(String)
-
+    config_trustedhosts = Column(String,default='')
    config_calibre_web_title = Column(String, default=u'Calibre-Web')
    config_books_per_page = Column(Integer, default=60)
    config_random_books = Column(Integer, default=4)
    config_authors_max = Column(Integer, default=0)
    config_read_column = Column(Integer, default=0)
-    config_title_regex = Column(String, default=u'^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+')
+    config_title_regex = Column(String, default=r'^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+')
    config_mature_content_tags = Column(String, default='')
    config_theme = Column(Integer, default=0)

@@ -83,6 +89,8 @@ class _Settings(_Base):

    config_default_role = Column(SmallInteger, default=0)
    config_default_show = Column(SmallInteger, default=constants.ADMIN_USER_SIDEBAR)
+    config_default_language = Column(String(3), default="all")
+    config_default_locale = Column(String(2), default="en")
    config_columns_to_ignore = Column(String)

    config_denied_tags = Column(String, default="")
@@ -109,9 +117,12 @@ class _Settings(_Base):
    config_ldap_serv_username = Column(String, default='cn=admin,dc=example,dc=org')
    config_ldap_serv_password = Column(String, default="")
    config_ldap_encryption = Column(SmallInteger, default=0)
+    config_ldap_cacert_path = Column(String, default="")
    config_ldap_cert_path = Column(String, default="")
+    config_ldap_key_path = Column(String, default="")
    config_ldap_dn = Column(String, default='dc=example,dc=org')
    config_ldap_user_object = Column(String, default='uid=%s')
+    config_ldap_member_user_object = Column(String, default='') #
    config_ldap_openldap = Column(Boolean, default=True)
    config_ldap_group_object_filter = Column(String, default='(&(objectclass=posixGroup)(cn=%s))')
    config_ldap_group_members_field = Column(String, default='memberUid')
@@ -122,6 +133,7 @@ class _Settings(_Base):
    config_calibre = Column(String)
    config_rarfile_location = Column(String, default=None)
    config_upload_formats = Column(String, default=','.join(constants.EXTENSIONS_UPLOAD))
+    config_unicode_filename =Column(Boolean, default=False)

    config_updatechannel = Column(Integer, default=constants.UPDATE_STABLE)

@@ -143,15 +155,16 @@ class _ConfigSQL(object):
        self.load()

        change = False
-        if self.config_converterpath == None:
+        if self.config_converterpath == None:  # pylint: disable=access-member-before-definition
            change = True
            self.config_converterpath = autodetect_calibre_binary()

-        if self.config_kepubifypath == None:
+        if self.config_kepubifypath == None:  # pylint: disable=access-member-before-definition
+
            change = True
            self.config_kepubifypath = autodetect_kepubify_binary()

-        if self.config_rarfile_location == None:
+        if self.config_rarfile_location == None:  # pylint: disable=access-member-before-definition
            change = True
            self.config_rarfile_location = autodetect_unrar_binary()
        if change:
@@ -178,8 +191,9 @@ class _ConfigSQL(object):
            return None
        return self.config_keyfile

-    def get_config_ipaddress(self):
-        return cli.ipadress or ""
+    @staticmethod
+    def get_config_ipaddress():
+        return cli.ip_address or ""

    def _has_role(self, role_flag):
        return constants.has_flag(self.config_default_role, role_flag)
@@ -237,18 +251,18 @@ class _ConfigSQL(object):
        return {k:v for k, v in self.__dict__.items() if k.startswith('mail_')}

    def get_mail_server_configured(self):
-        return not bool(self.mail_server == constants.DEFAULT_MAIL_SERVER)
+        return bool((self.mail_server != constants.DEFAULT_MAIL_SERVER and self.mail_server_type == 0)
+                    or (self.mail_gmail_token != {} and self.mail_server_type == 1))


    def set_from_dictionary(self, dictionary, field, convertor=None, default=None, encode=None):
-        '''Possibly updates a field of this object.
+        """Possibly updates a field of this object.
        The new value, if present, is grabbed from the given dictionary, and optionally passed through a convertor.

        :returns: `True` if the field has changed value
-        '''
+        """
        new_value = dictionary.get(field, default)
        if new_value is None:
-            # log.debug("_ConfigSQL set_from_dictionary field '%s' not found", field)
            return False

        if field not in self.__dict__:
@@ -265,10 +279,17 @@ class _ConfigSQL(object):
        if current_value == new_value:
            return False

-        # log.debug("_ConfigSQL set_from_dictionary '%s' = %r (was %r)", field, new_value, current_value)
        setattr(self, field, new_value)
        return True

+    def toDict(self):
+        storage = {}
+        for k, v in self.__dict__.items():
+            if k[0] != '_' and not k.endswith("password") and not k.endswith("secret"):
+                storage[k] = v
+        return storage
+
+
    def load(self):
        '''Load all configuration values from the underlying storage.'''
        s = self._read_from_storage()  # type: _Settings
@@ -287,13 +308,21 @@ class _ConfigSQL(object):
                db_file = os.path.join(self.config_calibre_dir, 'metadata.db')
                have_metadata_db = os.path.isfile(db_file)
        self.db_configured = have_metadata_db
-        constants.EXTENSIONS_UPLOAD = [x.lstrip().rstrip() for x in self.config_upload_formats.split(',')]
-        logfile = logger.setup(self.config_logfile, self.config_log_level)
+        constants.EXTENSIONS_UPLOAD = [x.lstrip().rstrip().lower() for x in self.config_upload_formats.split(',')]
+        if os.environ.get('FLASK_DEBUG'):
+            logfile = logger.setup(logger.LOG_TO_STDOUT, logger.logging.DEBUG)
+        else:
+            # pylint: disable=access-member-before-definition
+            logfile = logger.setup(self.config_logfile, self.config_log_level)
        if logfile != self.config_logfile:
            log.warning("Log path %s not valid, falling back to default", self.config_logfile)
            self.config_logfile = logfile
            self._session.merge(s)
-            self._session.commit()
+            try:
+                self._session.commit()
+            except OperationalError as e:
+                log.error('Database error: %s', e)
+                self._session.rollback()

    def save(self):
        '''Apply all configuration values to the underlying storage.'''
@@ -307,7 +336,11 @@ class _ConfigSQL(object):

        log.debug("_ConfigSQL updating storage")
        self._session.merge(s)
-        self._session.commit()
+        try:
+            self._session.commit()
+        except OperationalError as e:
+            log.error('Database error: %s', e)
+            self._session.rollback()
        self.load()

    def invalidate(self, error=None):
@@ -315,7 +348,7 @@ class _ConfigSQL(object):
            log.error(error)
        log.warning("invalidating configuration")
        self.db_configured = False
-        self.config_calibre_dir = None
+        # self.config_calibre_dir = None
        self.save()


@@ -326,29 +359,35 @@ def _migrate_table(session, orm_class):
        if column_name[0] != '_':
            try:
                session.query(column).first()
-            except exc.OperationalError as err:
+            except OperationalError as err:
                log.debug("%s: %s", column_name, err.args[0])
-                if column.default is not None:
-                    if sys.version_info < (3, 0):
-                        if isinstance(column.default.arg, unicode):
-                            column.default.arg = column.default.arg.encode('utf-8')
                if column.default is None:
                    column_default = ""
                else:
                    if isinstance(column.default.arg, bool):
-                        column_default = ("DEFAULT %r" % int(column.default.arg))
+                        column_default = "DEFAULT {}".format(int(column.default.arg))
                    else:
-                        column_default = ("DEFAULT %r" % column.default.arg)
-                alter_table = "ALTER TABLE %s ADD COLUMN `%s` %s %s" % (orm_class.__tablename__,
+                        column_default = "DEFAULT `{}`".format(column.default.arg)
+                if isinstance(column.type, JSON):
+                    column_type = "JSON"
+                else:
+                    column_type = column.type
+                alter_table = text("ALTER TABLE %s ADD COLUMN `%s` %s %s" % (orm_class.__tablename__,
                                                                        column_name,
-                                                                        column.type,
-                                                                        column_default)
+                                                                        column_type,
+                                                                        column_default))
                log.debug(alter_table)
                session.execute(alter_table)
                changed = True
+            except json.decoder.JSONDecodeError as e:
+                log.error("Database corrupt column: {}".format(column_name))
+                log.debug(e)

    if changed:
-        session.commit()
+        try:
+            session.commit()
+        except OperationalError:
+            session.rollback()


 def autodetect_calibre_binary():
@@ -401,12 +440,12 @@ def load_configuration(session):
        session.commit()
    conf = _ConfigSQL(session)
    # Migrate from global restrictions to user based restrictions
-    if bool(conf.config_default_show & constants.MATURE_CONTENT) and conf.config_denied_tags == "":
-        conf.config_denied_tags = conf.config_mature_content_tags
-        conf.save()
-        session.query(ub.User).filter(ub.User.mature_content != True). \
-            update({"denied_tags": conf.config_mature_content_tags}, synchronize_session=False)
-        session.commit()
+    #if bool(conf.config_default_show & constants.MATURE_CONTENT) and conf.config_denied_tags == "":
+    #    conf.config_denied_tags = conf.config_mature_content_tags
+    #    conf.save()
+    #    session.query(ub.User).filter(ub.User.mature_content != True). \
+    #        update({"denied_tags": conf.config_mature_content_tags}, synchronize_session=False)
+    #    session.commit()
    return conf

 def get_flask_session_key(session):
@@ -16,20 +16,21 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import sys
 import os
 from collections import namedtuple
+from sqlalchemy import __version__ as sql_version

-HOME_CONFIG = False
+sqlalchemy_version2 = ([int(x) for x in sql_version.split('.')] >= [2,0,0])
+
+# if installed via pip this variable is set to true (empty file with name .HOMEDIR present)
+HOME_CONFIG = os.path.isfile(os.path.join(os.path.dirname(os.path.abspath(__file__)), '.HOMEDIR'))
+
+#In executables updater is not available, so variable is set to False there
+UPDATER_AVAILABLE = True

 # Base dir is parent of current file, necessary if called from different folder
-if sys.version_info < (3, 0):
-    BASE_DIR            = os.path.abspath(os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),os.pardir)).decode('utf-8')
-else:
-    BASE_DIR            = os.path.abspath(os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),os.pardir))
+BASE_DIR            = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),os.pardir))
 STATIC_DIR          = os.path.join(BASE_DIR, 'cps', 'static')
 TEMPLATES_DIR       = os.path.join(BASE_DIR, 'cps', 'templates')
 TRANSLATIONS_DIR    = os.path.join(BASE_DIR, 'cps', 'translations')
@@ -40,7 +41,7 @@ if HOME_CONFIG:
        os.makedirs(home_dir)
    CONFIG_DIR = os.environ.get('CALIBRE_DBPATH', home_dir)
 else:
-    CONFIG_DIR      = os.environ.get('CALIBRE_DBPATH', BASE_DIR)
+    CONFIG_DIR = os.environ.get('CALIBRE_DBPATH', BASE_DIR)


 ROLE_USER               = 0 << 0
@@ -81,10 +82,31 @@ SIDEBAR_PUBLISHER       = 1 << 12
 SIDEBAR_RATING          = 1 << 13
 SIDEBAR_FORMAT          = 1 << 14
 SIDEBAR_ARCHIVED        = 1 << 15
-# SIDEBAR_LIST            = 1 << 16
+SIDEBAR_DOWNLOAD        = 1 << 16
+SIDEBAR_LIST            = 1 << 17
+
+sidebar_settings = {
+                "detail_random": DETAIL_RANDOM,
+                "sidebar_language": SIDEBAR_LANGUAGE,
+                "sidebar_series": SIDEBAR_SERIES,
+                "sidebar_category": SIDEBAR_CATEGORY,
+                "sidebar_random": SIDEBAR_RANDOM,
+                "sidebar_author": SIDEBAR_AUTHOR,
+                "sidebar_best_rated": SIDEBAR_BEST_RATED,
+                "sidebar_read_and_unread": SIDEBAR_READ_AND_UNREAD,
+                "sidebar_recent": SIDEBAR_RECENT,
+                "sidebar_sorted": SIDEBAR_SORTED,
+                "sidebar_publisher": SIDEBAR_PUBLISHER,
+                "sidebar_rating": SIDEBAR_RATING,
+                "sidebar_format": SIDEBAR_FORMAT,
+                "sidebar_archived": SIDEBAR_ARCHIVED,
+                "sidebar_download": SIDEBAR_DOWNLOAD,
+                "sidebar_list": SIDEBAR_LIST,
+            }
+

 ADMIN_USER_ROLES        = sum(r for r in ALL_ROLES.values()) & ~ROLE_ANONYMOUS
-ADMIN_USER_SIDEBAR      = (SIDEBAR_ARCHIVED << 1) - 1
+ADMIN_USER_SIDEBAR      = (SIDEBAR_LIST << 1) - 1

 UPDATE_STABLE       = 0 << 0
 AUTO_UPDATE_STABLE  = 1 << 0
@@ -101,7 +123,7 @@ LDAP_AUTH_SIMPLE         = 0

 DEFAULT_MAIL_SERVER = "mail.example.org"

-DEFAULT_PASSWORD    = "admin123"
+DEFAULT_PASSWORD    = "admin123"  # nosec
 DEFAULT_PORT        = 8083
 env_CALIBRE_PORT = os.environ.get("CALIBRE_PORT", DEFAULT_PORT)
 try:
@@ -112,7 +134,8 @@ del env_CALIBRE_PORT


 EXTENSIONS_AUDIO    = {'mp3', 'mp4', 'ogg', 'opus', 'wav', 'flac', 'm4a', 'm4b'}
-EXTENSIONS_CONVERT  = ['pdf', 'epub', 'mobi', 'azw3', 'docx', 'rtf', 'fb2', 'lit', 'lrf', 'txt', 'htmlz', 'rtf', 'odt']
+EXTENSIONS_CONVERT_FROM  = ['pdf', 'epub', 'mobi', 'azw3', 'docx', 'rtf', 'fb2', 'lit', 'lrf', 'txt', 'htmlz', 'rtf', 'odt','cbz','cbr']
+EXTENSIONS_CONVERT_TO  = ['pdf', 'epub', 'mobi', 'azw3', 'docx', 'rtf', 'fb2', 'lit', 'lrf', 'txt', 'htmlz', 'rtf', 'odt']
 EXTENSIONS_UPLOAD   = {'txt', 'pdf', 'epub', 'kepub', 'mobi', 'azw', 'azw3', 'cbr', 'cbz', 'cbt', 'djvu', 'prc', 'doc', 'docx',
                       'fb2', 'html', 'rtf', 'lit', 'odt', 'mp3', 'mp4', 'ogg', 'opus', 'wav', 'flac', 'm4a', 'm4b'}

@@ -126,9 +149,9 @@ def selected_roles(dictionary):

 # :rtype: BookMeta
 BookMeta = namedtuple('BookMeta', 'file_path, extension, title, author, cover, description, tags, series, '
-                                  'series_id, languages')
+                                  'series_id, languages, publisher')

-STABLE_VERSION = {'version': '0.6.9'}
+STABLE_VERSION = {'version': '0.6.16'}

 NIGHTLY_VERSION = {}
 NIGHTLY_VERSION[0] = '$Format:%H$'
@@ -16,10 +16,8 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
 import re
-import sys
 from flask_babel import gettext as _

 from . import config, logger
@@ -40,9 +38,9 @@ def _get_command_version(path, pattern, argument=None):
        if argument:
            command.append(argument)
        try:
-            for line in process_wait(command):
-                if re.search(pattern, line):
-                    return line
+            match = process_wait(command, pattern=pattern)
+            if isinstance(match, re.Match):
+                return match.string
        except Exception as ex:
            log.warning("%s: %s", path, ex)
            return _EXECUTION_ERROR
@@ -17,73 +17,82 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import sys
 import os
 import re
 import ast
 import json
 from datetime import datetime
-import threading
+from urllib.parse import quote

 from sqlalchemy import create_engine
 from sqlalchemy import Table, Column, ForeignKey, CheckConstraint
 from sqlalchemy import String, Integer, Boolean, TIMESTAMP, Float
 from sqlalchemy.orm import relationship, sessionmaker, scoped_session
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm.collections import InstrumentedList
+from sqlalchemy.ext.declarative import DeclarativeMeta
 from sqlalchemy.exc import OperationalError
+try:
+    # Compatibility with sqlalchemy 2.0
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.pool import StaticPool
-from flask_login import current_user
 from sqlalchemy.sql.expression import and_, true, false, text, func, or_
 from sqlalchemy.ext.associationproxy import association_proxy
+from flask_login import current_user
 from babel import Locale as LC
 from babel.core import UnknownLocaleError
 from flask_babel import gettext as _
+from flask import flash

 from . import logger, ub, isoLanguages
 from .pagination import Pagination

+from weakref import WeakSet
+
 try:
    import unidecode
    use_unidecode = True
 except ImportError:
    use_unidecode = False

+log = logger.create()

-cc_exceptions = ['datetime', 'comments', 'composite', 'series']
+cc_exceptions = ['composite', 'series']
 cc_classes = {}

 Base = declarative_base()

 books_authors_link = Table('books_authors_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('author', Integer, ForeignKey('authors.id'), primary_key=True)
-    )
+                           Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                           Column('author', Integer, ForeignKey('authors.id'), primary_key=True)
+                           )

 books_tags_link = Table('books_tags_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('tag', Integer, ForeignKey('tags.id'), primary_key=True)
-    )
+                        Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                        Column('tag', Integer, ForeignKey('tags.id'), primary_key=True)
+                        )

 books_series_link = Table('books_series_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('series', Integer, ForeignKey('series.id'), primary_key=True)
-    )
+                          Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                          Column('series', Integer, ForeignKey('series.id'), primary_key=True)
+                          )

 books_ratings_link = Table('books_ratings_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('rating', Integer, ForeignKey('ratings.id'), primary_key=True)
-    )
+                           Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                           Column('rating', Integer, ForeignKey('ratings.id'), primary_key=True)
+                           )

 books_languages_link = Table('books_languages_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('lang_code', Integer, ForeignKey('languages.id'), primary_key=True)
-    )
+                             Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                             Column('lang_code', Integer, ForeignKey('languages.id'), primary_key=True)
+                             )

 books_publishers_link = Table('books_publishers_link', Base.metadata,
-    Column('book', Integer, ForeignKey('books.id'), primary_key=True),
-    Column('publisher', Integer, ForeignKey('publishers.id'), primary_key=True)
-    )
+                              Column('book', Integer, ForeignKey('books.id'), primary_key=True),
+                              Column('publisher', Integer, ForeignKey('publishers.id'), primary_key=True)
+                              )


 class Identifiers(Base):
@@ -113,6 +122,8 @@ class Identifiers(Base):
            return u"Douban"
        elif format_type == "goodreads":
            return u"Goodreads"
+        elif format_type == "babelio":
+            return u"Babelio"
        elif format_type == "google":
            return u"Google Books"
        elif format_type == "kobo":
@@ -140,6 +151,8 @@ class Identifiers(Base):
            return u"https://dx.doi.org/{0}".format(self.val)
        elif format_type == "goodreads":
            return u"https://www.goodreads.com/book/show/{0}".format(self.val)
+        elif format_type == "babelio":
+            return u"https://www.babelio.com/livres/titre/{0}".format(self.val)
        elif format_type == "douban":
            return u"https://book.douban.com/subject/{0}".format(self.val)
        elif format_type == "google":
@@ -147,30 +160,33 @@ class Identifiers(Base):
        elif format_type == "kobo":
            return u"https://www.kobo.com/ebook/{0}".format(self.val)
        elif format_type == "lubimyczytac":
-            return u" https://lubimyczytac.pl/ksiazka/{0}/ksiazka".format(self.val)
+            return u"https://lubimyczytac.pl/ksiazka/{0}/ksiazka".format(self.val)
        elif format_type == "litres":
            return u"https://www.litres.ru/{0}".format(self.val)
        elif format_type == "issn":
            return u"https://portal.issn.org/resource/ISSN/{0}".format(self.val)
        elif format_type == "isfdb":
            return u"http://www.isfdb.org/cgi-bin/pl.cgi?{0}".format(self.val)
-        elif format_type == "url":
-            return u"{0}".format(self.val)
+        elif self.val.lower().startswith("javascript:"):
+            return quote(self.val)
        else:
-            return u""
+            return u"{0}".format(self.val)


 class Comments(Base):
    __tablename__ = 'comments'

    id = Column(Integer, primary_key=True)
+    book = Column(Integer, ForeignKey('books.id'), nullable=False, unique=True)
    text = Column(String(collation='NOCASE'), nullable=False)
-    book = Column(Integer, ForeignKey('books.id'), nullable=False)

    def __init__(self, text, book):
        self.text = text
        self.book = book

+    def get(self):
+        return self.text
+
    def __repr__(self):
        return u"<Comments({0})>".format(self.text)

@@ -184,6 +200,9 @@ class Tags(Base):
    def __init__(self, name):
        self.name = name

+    def get(self):
+        return self.name
+
    def __repr__(self):
        return u"<Tags('{0})>".format(self.name)

@@ -201,6 +220,9 @@ class Authors(Base):
        self.sort = sort
        self.link = link

+    def get(self):
+        return self.name
+
    def __repr__(self):
        return u"<Authors('{0},{1}{2}')>".format(self.name, self.sort, self.link)

@@ -216,6 +238,9 @@ class Series(Base):
        self.name = name
        self.sort = sort

+    def get(self):
+        return self.name
+
    def __repr__(self):
        return u"<Series('{0},{1}')>".format(self.name, self.sort)

@@ -229,6 +254,9 @@ class Ratings(Base):
    def __init__(self, rating):
        self.rating = rating

+    def get(self):
+        return self.rating
+
    def __repr__(self):
        return u"<Ratings('{0}')>".format(self.rating)

@@ -242,6 +270,12 @@ class Languages(Base):
    def __init__(self, lang_code):
        self.lang_code = lang_code

+    def get(self):
+        if self.language_name:
+            return self.language_name
+        else:
+            return self.lang_code
+
    def __repr__(self):
        return u"<Languages('{0}')>".format(self.lang_code)

@@ -257,13 +291,16 @@ class Publishers(Base):
        self.name = name
        self.sort = sort

+    def get(self):
+        return self.name
+
    def __repr__(self):
        return u"<Publishers('{0},{1}')>".format(self.name, self.sort)


 class Data(Base):
    __tablename__ = 'data'
-    __table_args__ = {'schema':'calibre'}
+    __table_args__ = {'schema': 'calibre'}

    id = Column(Integer, primary_key=True)
    book = Column(Integer, ForeignKey('books.id'), nullable=False)
@@ -277,6 +314,10 @@ class Data(Base):
        self.uncompressed_size = uncompressed_size
        self.name = name

+    # ToDo: Check
+    def get(self):
+        return self.name
+
    def __repr__(self):
        return u"<Data('{0},{1}{2}{3}')>".format(self.book, self.format, self.uncompressed_size, self.name)

@@ -284,21 +325,20 @@ class Data(Base):
 class Books(Base):
    __tablename__ = 'books'

-    DEFAULT_PUBDATE = "0101-01-01 00:00:00+00:00"
+    DEFAULT_PUBDATE = datetime(101, 1, 1, 0, 0, 0, 0)  # ("0101-01-01 00:00:00+00:00")

    id = Column(Integer, primary_key=True, autoincrement=True)
    title = Column(String(collation='NOCASE'), nullable=False, default='Unknown')
    sort = Column(String(collation='NOCASE'))
    author_sort = Column(String(collation='NOCASE'))
    timestamp = Column(TIMESTAMP, default=datetime.utcnow)
-    pubdate = Column(String) # , default=datetime.utcnow)
+    pubdate = Column(TIMESTAMP, default=DEFAULT_PUBDATE)
    series_index = Column(String, nullable=False, default="1.0")
    last_modified = Column(TIMESTAMP, default=datetime.utcnow)
    path = Column(String, default="", nullable=False)
    has_cover = Column(Integer, default=0)
    uuid = Column(String)
    isbn = Column(String(collation='NOCASE'), default="")
-    # Iccn = Column(String(collation='NOCASE'), default="")
    flags = Column(Integer, nullable=False, default=1)

    authors = relationship('Authors', secondary=books_authors_link, backref='books')
@@ -321,7 +361,8 @@ class Books(Base):
        self.series_index = series_index
        self.last_modified = last_modified
        self.path = path
-        self.has_cover = has_cover
+        self.has_cover = (has_cover != None)
+

    def __repr__(self):
        return u"<Books('{0},{1}{2}{3}{4}{5}{6}{7}{8}')>".format(self.title, self.sort, self.author_sort,
@@ -332,6 +373,7 @@ class Books(Base):
    def atom_timestamp(self):
        return (self.timestamp.strftime('%Y-%m-%dT%H:%M:%S+00:00') or '')

+
 class Custom_Columns(Base):
    __tablename__ = 'custom_columns'

@@ -347,168 +389,230 @@ class Custom_Columns(Base):

    def get_display_dict(self):
        display_dict = ast.literal_eval(self.display)
-        if sys.version_info < (3, 0):
-            display_dict['enum_values'] = [x.decode('unicode_escape') for x in display_dict['enum_values']]
        return display_dict


-class CalibreDB(threading.Thread):
+class AlchemyEncoder(json.JSONEncoder):

-    def __init__(self):
-        threading.Thread.__init__(self)
-        self.engine = None
-        self.session = None
-        self.queue = None
-        self.log = None
-        self.config = None
-
-    def add_queue(self,queue):
-        self.queue = queue
-        self.log = logger.create()
-
-    def run(self):
-        while True:
-            i = self.queue.get()
-            if i == 'dummy':
-                self.queue.task_done()
-                break
-            if i['task'] == 'add_format':
-                cur_book = self.session.query(Books).filter(Books.id == i['id']).first()
-                cur_book.data.append(i['format'])
+    def default(self, o):
+        if isinstance(o.__class__, DeclarativeMeta):
+            # an SQLAlchemy class
+            fields = {}
+            for field in [x for x in dir(o) if not x.startswith('_') and x != 'metadata' and x != "password"]:
+                if field == 'books':
+                    continue
+                data = o.__getattribute__(field)
                try:
-                    # db.session.merge(cur_book)
-                    self.session.commit()
-                except OperationalError as e:
-                    self.session.rollback()
-                    self.log.error("Database error: %s", e)
-                    # self._handleError(_(u"Database error: %(error)s.", error=e))
-                    # return
-            self.queue.task_done()
+                    if isinstance(data, str):
+                        data = data.replace("'", "\'")
+                    elif isinstance(data, InstrumentedList):
+                        el = list()
+                        # ele = None
+                        for ele in data:
+                            if hasattr(ele, 'value'):       # converter for custom_column values
+                                el.append(str(ele.value))
+                            elif ele.get:
+                                el.append(ele.get())
+                            else:
+                                el.append(json.dumps(ele, cls=AlchemyEncoder))
+                        if field == 'authors':
+                            data = " & ".join(el)
+                        else:
+                            data = ",".join(el)
+                        if data == '[]':
+                            data = ""
+                    else:
+                        json.dumps(data)
+                    fields[field] = data
+                except Exception:
+                    fields[field] = ""
+            # a json-encodable dict
+            return fields
+
+        return json.JSONEncoder.default(self, o)


-    def stop(self):
-        self.queue.put('dummy')
+class CalibreDB():
+    _init = False
+    engine = None
+    config = None
+    session_factory = None
+    # This is a WeakSet so that references here don't keep other CalibreDB
+    # instances alive once they reach the end of their respective scopes
+    instances = WeakSet()

-    def setup_db(self, config, app_db_path):
-        self.config = config
-        self.dispose()
+    def __init__(self, expire_on_commit=True):
+        """ Initialize a new CalibreDB session
+        """
+        self.session = None
+        if self._init:
+            self.initSession(expire_on_commit)

-        if not config.config_calibre_dir:
-            config.invalidate()
-            return False
+        self.instances.add(self)

-        dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
-        if not os.path.exists(dbpath):
-            config.invalidate()
-            return False
+    def initSession(self, expire_on_commit=True):
+        self.session = self.session_factory()
+        self.session.expire_on_commit = expire_on_commit
+        self.update_title_sort(self.config)

-        try:
-            self.engine = create_engine('sqlite://',
-                                   echo=False,
-                                   isolation_level="SERIALIZABLE",
-                                   connect_args={'check_same_thread': False},
-                                   poolclass=StaticPool)
-            self.engine.execute("attach database '{}' as calibre;".format(dbpath))
-            self.engine.execute("attach database '{}' as app_settings;".format(app_db_path))
-
-            conn = self.engine.connect()
-            # conn.text_factory = lambda b: b.decode(errors = 'ignore') possible fix for #1302
-        except Exception as e:
-            config.invalidate(e)
-            return False
-
-        config.db_configured = True
-        self.update_title_sort(config, conn.connection)
-
-        if not cc_classes:
-            cc = conn.execute("SELECT id, datatype FROM custom_columns")
-
-            cc_ids = []
-            books_custom_column_links = {}
-            for row in cc:
-                if row.datatype not in cc_exceptions:
-                    if row.datatype == 'series':
-                        dicttable = {'__tablename__': 'books_custom_column_' + str(row.id) + '_link',
-                                     'id': Column(Integer, primary_key=True),
-                                     'book': Column(Integer, ForeignKey('books.id'),
-                                                    primary_key=True),
-                                     'map_value': Column('value', Integer,
+    @classmethod
+    def setup_db_cc_classes(self, cc):
+        cc_ids = []
+        books_custom_column_links = {}
+        for row in cc:
+            if row.datatype not in cc_exceptions:
+                if row.datatype == 'series':
+                    dicttable = {'__tablename__': 'books_custom_column_' + str(row.id) + '_link',
+                                 'id': Column(Integer, primary_key=True),
+                                 'book': Column(Integer, ForeignKey('books.id'),
+                                                primary_key=True),
+                                 'map_value': Column('value', Integer,
                                                     ForeignKey('custom_column_' +
                                                                str(row.id) + '.id'),
                                                     primary_key=True),
-                                     'extra': Column(Float),
-                                     'asoc' : relationship('custom_column_' + str(row.id), uselist=False),
-                                     'value' : association_proxy('asoc', 'value')
-                                     }
-                        books_custom_column_links[row.id] = type(str('books_custom_column_' + str(row.id) + '_link'),
-                                                                 (Base,), dicttable)
-                    else:
-                        books_custom_column_links[row.id] = Table('books_custom_column_' + str(row.id) + '_link',
-                                                                  Base.metadata,
-                                                                  Column('book', Integer, ForeignKey('books.id'),
-                                                                         primary_key=True),
-                                                                  Column('value', Integer,
-                                                                         ForeignKey('custom_column_' +
-                                                                                    str(row.id) + '.id'),
-                                                                         primary_key=True)
-                                                                  )
-                    cc_ids.append([row.id, row.datatype])
+                                 'extra': Column(Float),
+                                 'asoc': relationship('custom_column_' + str(row.id), uselist=False),
+                                 'value': association_proxy('asoc', 'value')
+                                 }
+                    books_custom_column_links[row.id] = type(str('books_custom_column_' + str(row.id) + '_link'),
+                                                             (Base,), dicttable)
+                if row.datatype in ['rating', 'text', 'enumeration']:
+                    books_custom_column_links[row.id] = Table('books_custom_column_' + str(row.id) + '_link',
+                                                              Base.metadata,
+                                                              Column('book', Integer, ForeignKey('books.id'),
+                                                                     primary_key=True),
+                                                              Column('value', Integer,
+                                                                     ForeignKey('custom_column_' +
+                                                                                str(row.id) + '.id'),
+                                                                     primary_key=True)
+                                                              )
+                cc_ids.append([row.id, row.datatype])

-                    ccdict = {'__tablename__': 'custom_column_' + str(row.id),
-                              'id': Column(Integer, primary_key=True)}
-                    if row.datatype == 'float':
-                        ccdict['value'] = Column(Float)
-                    elif row.datatype == 'int':
-                        ccdict['value'] = Column(Integer)
-                    elif row.datatype == 'bool':
-                        ccdict['value'] = Column(Boolean)
-                    else:
-                        ccdict['value'] = Column(String)
-                    if row.datatype in ['float', 'int', 'bool']:
-                        ccdict['book'] = Column(Integer, ForeignKey('books.id'))
-                    cc_classes[row.id] = type(str('custom_column_' + str(row.id)), (Base,), ccdict)
-
-            for cc_id in cc_ids:
-                if (cc_id[1] == 'bool') or (cc_id[1] == 'int') or (cc_id[1] == 'float'):
-                    setattr(Books,
-                            'custom_column_' + str(cc_id[0]),
-                            relationship(cc_classes[cc_id[0]],
-                                         primaryjoin=(
-                                         Books.id == cc_classes[cc_id[0]].book),
-                                         backref='books'))
-                elif (cc_id[1] == 'series'):
-                    setattr(Books,
-                            'custom_column_' + str(cc_id[0]),
-                            relationship(books_custom_column_links[cc_id[0]],
-                                         backref='books'))
+                ccdict = {'__tablename__': 'custom_column_' + str(row.id),
+                          'id': Column(Integer, primary_key=True)}
+                if row.datatype == 'float':
+                    ccdict['value'] = Column(Float)
+                elif row.datatype == 'int':
+                    ccdict['value'] = Column(Integer)
+                elif row.datatype == 'datetime':
+                    ccdict['value'] = Column(TIMESTAMP)
+                elif row.datatype == 'bool':
+                    ccdict['value'] = Column(Boolean)
                else:
-                    setattr(Books,
-                            'custom_column_' + str(cc_id[0]),
-                            relationship(cc_classes[cc_id[0]],
-                                         secondary=books_custom_column_links[cc_id[0]],
-                                         backref='books'))
+                    ccdict['value'] = Column(String)
+                if row.datatype in ['float', 'int', 'bool', 'datetime', 'comments']:
+                    ccdict['book'] = Column(Integer, ForeignKey('books.id'))
+                cc_classes[row.id] = type(str('custom_column_' + str(row.id)), (Base,), ccdict)

-        Session = scoped_session(sessionmaker(autocommit=False,
-                                              autoflush=False,
-                                              bind=self.engine))
-        self.session = Session()
+        for cc_id in cc_ids:
+            if cc_id[1] in ['bool', 'int', 'float', 'datetime', 'comments']:
+                setattr(Books,
+                        'custom_column_' + str(cc_id[0]),
+                        relationship(cc_classes[cc_id[0]],
+                                     primaryjoin=(
+                                         Books.id == cc_classes[cc_id[0]].book),
+                                     backref='books'))
+            elif cc_id[1] == 'series':
+                setattr(Books,
+                        'custom_column_' + str(cc_id[0]),
+                        relationship(books_custom_column_links[cc_id[0]],
+                                     backref='books'))
+            else:
+                setattr(Books,
+                        'custom_column_' + str(cc_id[0]),
+                        relationship(cc_classes[cc_id[0]],
+                                     secondary=books_custom_column_links[cc_id[0]],
+                                     backref='books'))
+
+        return cc_classes
+
+    @classmethod
+    def check_valid_db(cls, config_calibre_dir, app_db_path):
+        if not config_calibre_dir:
+            return False
+        dbpath = os.path.join(config_calibre_dir, "metadata.db")
+        if not os.path.exists(dbpath):
+            return False
+        try:
+            check_engine = create_engine('sqlite://',
+                          echo=False,
+                          isolation_level="SERIALIZABLE",
+                          connect_args={'check_same_thread': False},
+                          poolclass=StaticPool)
+            with check_engine.begin() as connection:
+                connection.execute(text("attach database '{}' as calibre;".format(dbpath)))
+                connection.execute(text("attach database '{}' as app_settings;".format(app_db_path)))
+            check_engine.connect()
+        except Exception:
+            return False
+        return True
+
+    @classmethod
+    def update_config(cls, config):
+        cls.config = config
+
+    @classmethod
+    def setup_db(cls, config_calibre_dir, app_db_path):
+        cls.dispose()
+
+        if not config_calibre_dir:
+            cls.config.invalidate()
+            return False
+
+        dbpath = os.path.join(config_calibre_dir, "metadata.db")
+        if not os.path.exists(dbpath):
+            cls.config.invalidate()
+            return False
+
+        try:
+            cls.engine = create_engine('sqlite://',
+                                       echo=False,
+                                       isolation_level="SERIALIZABLE",
+                                       connect_args={'check_same_thread': False},
+                                       poolclass=StaticPool)
+            with cls.engine.begin() as connection:
+                connection.execute(text("attach database '{}' as calibre;".format(dbpath)))
+                connection.execute(text("attach database '{}' as app_settings;".format(app_db_path)))
+
+            conn = cls.engine.connect()
+            # conn.text_factory = lambda b: b.decode(errors = 'ignore') possible fix for #1302
+        except Exception as ex:
+            cls.config.invalidate(ex)
+            return False
+
+        cls.config.db_configured = True
+
+        if not cc_classes:
+            try:
+                cc = conn.execute(text("SELECT id, datatype FROM custom_columns"))
+                cls.setup_db_cc_classes(cc)
+            except OperationalError as e:
+                log.debug_or_exception(e)
+
+        cls.session_factory = scoped_session(sessionmaker(autocommit=False,
+                                                          autoflush=True,
+                                                          bind=cls.engine))
+        for inst in cls.instances:
+            inst.initSession()
+
+        cls._init = True
        return True

    def get_book(self, book_id):
        return self.session.query(Books).filter(Books.id == book_id).first()

    def get_filtered_book(self, book_id, allow_show_archived=False):
-        return self.session.query(Books).filter(Books.id == book_id).\
+        return self.session.query(Books).filter(Books.id == book_id). \
            filter(self.common_filters(allow_show_archived)).first()

    def get_book_by_uuid(self, book_uuid):
        return self.session.query(Books).filter(Books.uuid == book_uuid).first()

-    def get_book_format(self, book_id, format):
-        return self.session.query(Data).filter(Data.book == book_id).filter(Data.format == format).first()
+    def get_book_format(self, book_id, file_format):
+        return self.session.query(Data).filter(Data.book == book_id).filter(Data.format == file_format).first()

    # Language and content filters for displaying in the UI
-    def common_filters(self, allow_show_archived=False):
+    def common_filters(self, allow_show_archived=False, return_all_languages=False):
        if not allow_show_archived:
            archived_books = (
                ub.session.query(ub.ArchivedBook)
@@ -521,51 +625,95 @@ class CalibreDB(threading.Thread):
        else:
            archived_filter = true()

-        if current_user.filter_language() != "all":
-            lang_filter = Books.languages.any(Languages.lang_code == current_user.filter_language())
-        else:
+        if current_user.filter_language() == "all" or return_all_languages:
            lang_filter = true()
+        else:
+            lang_filter = Books.languages.any(Languages.lang_code == current_user.filter_language())
        negtags_list = current_user.list_denied_tags()
        postags_list = current_user.list_allowed_tags()
        neg_content_tags_filter = false() if negtags_list == [''] else Books.tags.any(Tags.name.in_(negtags_list))
        pos_content_tags_filter = true() if postags_list == [''] else Books.tags.any(Tags.name.in_(postags_list))
        if self.config.config_restricted_column:
-            pos_cc_list = current_user.allowed_column_value.split(',')
-            pos_content_cc_filter = true() if pos_cc_list == [''] else \
-                getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
-                    any(cc_classes[self.config.config_restricted_column].value.in_(pos_cc_list))
-            neg_cc_list = current_user.denied_column_value.split(',')
-            neg_content_cc_filter = false() if neg_cc_list == [''] else \
-                getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
-                    any(cc_classes[self.config.config_restricted_column].value.in_(neg_cc_list))
+            try:
+                pos_cc_list = current_user.allowed_column_value.split(',')
+                pos_content_cc_filter = true() if pos_cc_list == [''] else \
+                    getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
+                        any(cc_classes[self.config.config_restricted_column].value.in_(pos_cc_list))
+                neg_cc_list = current_user.denied_column_value.split(',')
+                neg_content_cc_filter = false() if neg_cc_list == [''] else \
+                    getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
+                        any(cc_classes[self.config.config_restricted_column].value.in_(neg_cc_list))
+            except (KeyError, AttributeError):
+                pos_content_cc_filter = false()
+                neg_content_cc_filter = true()
+                log.error(u"Custom Column No.%d is not existing in calibre database",
+                          self.config.config_restricted_column)
+                flash(_("Custom Column No.%(column)d is not existing in calibre database",
+                        column=self.config.config_restricted_column),
+                      category="error")
+
        else:
            pos_content_cc_filter = true()
            neg_content_cc_filter = false()
        return and_(lang_filter, pos_content_tags_filter, ~neg_content_tags_filter,
                    pos_content_cc_filter, ~neg_content_cc_filter, archived_filter)

-    # Fill indexpage with all requested data from database
-    def fill_indexpage(self, page, database, db_filter, order, *join):
-        return self.fill_indexpage_with_archived_books(page, database, db_filter, order, False, *join)
+    @staticmethod
+    def get_checkbox_sorted(inputlist, state, offset, limit, order):
+        outcome = list()
+        elementlist = {ele.id: ele for ele in inputlist}
+        for entry in state:
+            try:
+                outcome.append(elementlist[entry])
+            except KeyError:
+                pass
+            del elementlist[entry]
+        for entry in elementlist:
+            outcome.append(elementlist[entry])
+        if order == "asc":
+            outcome.reverse()
+        return outcome[offset:offset + limit]

-    def fill_indexpage_with_archived_books(self, page, database, db_filter, order, allow_show_archived, *join):
+    # Fill indexpage with all requested data from database
+    def fill_indexpage(self, page, pagesize, database, db_filter, order, *join):
+        return self.fill_indexpage_with_archived_books(page, pagesize, database, db_filter, order, False, *join)
+
+    def fill_indexpage_with_archived_books(self, page, pagesize, database, db_filter, order, allow_show_archived,
+                                           *join):
+        pagesize = pagesize or self.config.config_books_per_page
        if current_user.show_detail_random():
            randm = self.session.query(Books) \
                .filter(self.common_filters(allow_show_archived)) \
                .order_by(func.random()) \
-                .limit(self.config.config_random_books)
+                .limit(self.config.config_random_books).all()
        else:
            randm = false()
-        off = int(int(self.config.config_books_per_page) * (page - 1))
-        query = self.session.query(database) \
-            .join(*join, isouter=True) \
-            .filter(db_filter) \
+        off = int(int(pagesize) * (page - 1))
+        query = self.session.query(database)
+        if len(join) == 6:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4]).outerjoin(join[5])
+        if len(join) == 5:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4])
+        if len(join) == 4:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3])
+        if len(join) == 3:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2])
+        elif len(join) == 2:
+            query = query.outerjoin(join[0], join[1])
+        elif len(join) == 1:
+            query = query.outerjoin(join[0])
+        query = query.filter(db_filter)\
            .filter(self.common_filters(allow_show_archived))
-        pagination = Pagination(page, self.config.config_books_per_page,
-                                len(query.all()))
-        entries = query.order_by(*order).offset(off).limit(self.config.config_books_per_page).all()
-        for book in entries:
-            book = self.order_authors(book)
+        entries = list()
+        pagination = list()
+        try:
+            pagination = Pagination(page, pagesize,
+                                    len(query.all()))
+            entries = query.order_by(*order).offset(off).limit(pagesize).all()
+        except Exception as ex:
+            log.debug_or_exception(ex)
+        #for book in entries:
+        #    book = self.order_authors(book)
        return entries, randm, pagination

    # Orders all Authors in the list according to authors sort
@@ -573,13 +721,16 @@ class CalibreDB(threading.Thread):
        sort_authors = entry.author_sort.split('&')
        authors_ordered = list()
        error = False
+        ids = [a.id for a in entry.authors]
        for auth in sort_authors:
+            results = self.session.query(Authors).filter(Authors.sort == auth.lstrip().strip()).all()
            # ToDo: How to handle not found authorname
-            result = self.session.query(Authors).filter(Authors.sort == auth.lstrip().strip()).first()
-            if not result:
+            if not len(results):
                error = True
                break
-            authors_ordered.append(result)
+            for r in results:
+                if r.id in ids:
+                    authors_ordered.append(r)
        if not error:
            entry.authors = authors_ordered
        return entry
@@ -589,6 +740,7 @@ class CalibreDB(threading.Thread):
        self.session.connection().connection.connection.create_function("lower", 1, lcase)
        entries = self.session.query(database).filter(tag_filter). \
            filter(func.lower(database.name).ilike("%" + query + "%")).all()
+        # json_dumps = json.dumps([dict(name=escape(r.name.replace(*replace))) for r in entries])
        json_dumps = json.dumps([dict(name=r.name.replace(*replace)) for r in entries])
        return json_dumps

@@ -599,42 +751,74 @@ class CalibreDB(threading.Thread):
        for authorterm in authorterms:
            q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + authorterm + "%")))

-        return self.session.query(Books)\
+        return self.session.query(Books) \
            .filter(and_(Books.authors.any(and_(*q)), func.lower(Books.title).ilike("%" + title + "%"))).first()

-    # read search results from calibre-database and return it (function is used for feed and simple search
-    def get_search_results(self, term):
+    def search_query(self, term, *join):
        term.strip().lower()
        self.session.connection().connection.connection.create_function("lower", 1, lcase)
        q = list()
        authorterms = re.split("[, ]+", term)
        for authorterm in authorterms:
            q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + authorterm + "%")))
-        return self.session.query(Books).filter(self.common_filters(True)).filter(
+        query = self.session.query(Books)
+        if len(join) == 6:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4]).outerjoin(join[5])
+        if len(join) == 3:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2])
+        elif len(join) == 2:
+            query = query.outerjoin(join[0], join[1])
+        elif len(join) == 1:
+            query = query.outerjoin(join[0])
+        return query.filter(self.common_filters(True)).filter(
            or_(Books.tags.any(func.lower(Tags.name).ilike("%" + term + "%")),
                Books.series.any(func.lower(Series.name).ilike("%" + term + "%")),
                Books.authors.any(and_(*q)),
                Books.publishers.any(func.lower(Publishers.name).ilike("%" + term + "%")),
                func.lower(Books.title).ilike("%" + term + "%")
-                )).order_by(Books.sort).all()
+                ))
+
+    # read search results from calibre-database and return it (function is used for feed and simple search
+    def get_search_results(self, term, offset=None, order=None, limit=None, *join):
+        order = order[0] if order else [Books.sort]
+        pagination = None
+        result = self.search_query(term, *join).order_by(*order).all()
+        result_count = len(result)
+        if offset != None and limit != None:
+            offset = int(offset)
+            limit_all = offset + int(limit)
+            pagination = Pagination((offset / (int(limit)) + 1), limit, result_count)
+        else:
+            offset = 0
+            limit_all = result_count
+
+        ub.store_ids(result)
+        return result[offset:limit_all], result_count, pagination

    # Creates for all stored languages a translated speaking name in the array for the UI
-    def speaking_language(self, languages=None):
+    def speaking_language(self, languages=None, return_all_languages=False, with_count=False, reverse_order=False):
        from . import get_locale

-        if not languages:
-            languages = self.session.query(Languages) \
-                .join(books_languages_link) \
-                .join(Books) \
-                .filter(self.common_filters()) \
-                .group_by(text('books_languages_link.lang_code')).all()
-        for lang in languages:
-            try:
-                cur_l = LC.parse(lang.lang_code)
-                lang.name = cur_l.get_language_name(get_locale())
-            except UnknownLocaleError:
-                lang.name = _(isoLanguages.get(part3=lang.lang_code).name)
-        return languages
+        if with_count:
+            if not languages:
+                languages = self.session.query(Languages, func.count('books_languages_link.book'))\
+                    .join(books_languages_link).join(Books)\
+                    .filter(self.common_filters(return_all_languages=return_all_languages)) \
+                    .group_by(text('books_languages_link.lang_code')).all()
+            for lang in languages:
+                lang[0].name = isoLanguages.get_language_name(get_locale(), lang[0].lang_code)
+            return sorted(languages, key=lambda x: x[0].name, reverse=reverse_order)
+        else:
+            if not languages:
+                languages = self.session.query(Languages) \
+                    .join(books_languages_link) \
+                    .join(Books) \
+                    .filter(self.common_filters(return_all_languages=return_all_languages)) \
+                    .group_by(text('books_languages_link.lang_code')).all()
+            for lang in languages:
+                lang.name = isoLanguages.get_language_name(get_locale(), lang.lang_code)
+            return sorted(languages, key=lambda x: x.name, reverse=reverse_order)
+

    def update_title_sort(self, config, conn=None):
        # user defined sort function for calibre databases (Series, etc.)
@@ -650,17 +834,23 @@ class CalibreDB(threading.Thread):
        conn = conn or self.session.connection().connection.connection
        conn.create_function("title_sort", 1, _title_sort)

-    def dispose(self):
+    @classmethod
+    def dispose(cls):
        # global session

-        old_session = self.session
-        self.session = None
-        if old_session:
-            try: old_session.close()
-            except: pass
-            if old_session.bind:
-                try: old_session.bind.dispose()
-                except Exception: pass
+        for inst in cls.instances:
+            old_session = inst.session
+            inst.session = None
+            if old_session:
+                try:
+                    old_session.close()
+                except Exception:
+                    pass
+                if old_session.bind:
+                    try:
+                        old_session.bind.dispose()
+                    except Exception:
+                        pass

        for attr in list(Books.__dict__.keys()):
            if attr.startswith("custom_column_"):
@@ -677,14 +867,16 @@ class CalibreDB(threading.Thread):
                    Base.metadata.remove(table)

    def reconnect_db(self, config, app_db_path):
-        self.session.close()
+        self.dispose()
        self.engine.dispose()
-        self.setup_db(config, app_db_path)
+        self.setup_db(config.config_calibre_dir, app_db_path)
+        self.update_config(config)
+

 def lcase(s):
    try:
        return unidecode.unidecode(s.lower())
-    except Exception as e:
+    except Exception as ex:
        log = logger.create()
-        log.exception(e)
+        log.debug_or_exception(ex)
        return s.lower()
@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2012-2019 cervinko, idalin, SiphonSquirrel, ouzklcn, akushsky,
+#                            OzzieIsaacs, bodybybuddha, jkrehm, matthazinski, janeczku
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import shutil
+import glob
+import zipfile
+import json
+from io import BytesIO
+
+import os
+
+from flask import send_file, __version__
+
+from . import logger, config
+from .about import collect_stats
+
+log = logger.create()
+
+def assemble_logfiles(file_name):
+    log_list = sorted(glob.glob(file_name + '*'), reverse=True)
+    wfd = BytesIO()
+    for f in log_list:
+        with open(f, 'rb') as fd:
+            shutil.copyfileobj(fd, wfd)
+    wfd.seek(0)
+    if int(__version__.split('.')[0]) < 2:
+        return send_file(wfd,
+                         as_attachment=True,
+                         attachment_filename=os.path.basename(file_name))
+    else:
+        return send_file(wfd,
+                         as_attachment=True,
+                         download_name=os.path.basename(file_name))
+
+
+def send_debug():
+    file_list = glob.glob(logger.get_logfile(config.config_logfile) + '*')
+    file_list.extend(glob.glob(logger.get_accesslogfile(config.config_access_logfile) + '*'))
+    for element in [logger.LOG_TO_STDOUT, logger.LOG_TO_STDERR]:
+        if element in file_list:
+            file_list.remove(element)
+    memory_zip = BytesIO()
+    with zipfile.ZipFile(memory_zip, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr('settings.txt', json.dumps(config.toDict()))
+        zf.writestr('libs.txt', json.dumps(collect_stats()))
+        for fp in file_list:
+            zf.write(fp, os.path.basename(fp))
+    memory_zip.seek(0)
+    if int(__version__.split('.')[0]) < 2:
+        return send_file(memory_zip,
+                         as_attachment=True,
+                         attachment_filename="Calibre-Web-debug-pack.zip")
+    else:
+        return send_file(memory_zip,
+                         as_attachment=True,
+                         download_name="Calibre-Web-debug-pack.zip")
@@ -0,0 +1,96 @@
+import os
+import re
+
+from .constants import BASE_DIR
+try:
+    from importlib_metadata import version
+    importlib = True
+    ImportNotFound = BaseException
+except ImportError:
+    importlib = False
+
+
+if not importlib:
+    try:
+        import pkg_resources
+        from pkg_resources import DistributionNotFound as ImportNotFound
+        pkgresources = True
+    except ImportError as e:
+        pkgresources = False
+
+def load_dependencys(optional=False):
+    deps = list()
+    if importlib or pkgresources:
+        if optional:
+            req_path = os.path.join(BASE_DIR, "optional-requirements.txt")
+        else:
+            req_path = os.path.join(BASE_DIR, "requirements.txt")
+        if os.path.exists(req_path):
+            with open(req_path, 'r') as f:
+                for line in f:
+                    if not line.startswith('#') and not line == '\n' and not line.startswith('git'):
+                        res = re.match(r'(.*?)([<=>\s]+)([\d\.]+),?\s?([<=>\s]+)?([\d\.]+)?', line.strip())
+                        try:
+                            if importlib:
+                                dep_version = version(res.group(1))
+                            else:
+                                dep_version = pkg_resources.get_distribution(res.group(1)).version
+                        except ImportNotFound:
+                            if optional:
+                                continue
+                            dep_version = "not installed"
+                        deps.append([dep_version, res.group(1), res.group(2), res.group(3), res.group(4), res.group(5)])
+    return deps
+
+
+def dependency_check(optional=False):
+    d = list()
+    deps = load_dependencys(optional)
+    for dep in deps:
+        try:
+            dep_version_int = [int(x) for x in dep[0].split('.')]
+            low_check = [int(x) for x in dep[3].split('.')]
+            high_check = [int(x) for x in dep[5].split('.')]
+        except AttributeError:
+            high_check = None
+        except ValueError:
+            d.append({'name': dep[1],
+                     'target': "available",
+                     'found': "Not available"
+                     })
+            continue
+
+        if dep[2].strip() == "==":
+            if dep_version_int != low_check:
+                d.append({'name': dep[1],
+                            'found': dep[0],
+                            "target": dep[2] + dep[3]})
+                continue
+        elif dep[2].strip() == ">=":
+            if dep_version_int < low_check:
+                d.append({'name': dep[1],
+                            'found': dep[0],
+                            "target": dep[2] + dep[3]})
+                continue
+        elif dep[2].strip() == ">":
+            if dep_version_int <= low_check:
+                d.append({'name': dep[1],
+                            'found': dep[0],
+                            "target": dep[2] + dep[3]})
+                continue
+        if dep[4] and dep[5]:
+            if dep[4].strip() == "<":
+                if dep_version_int >= high_check:
+                    d.append(
+                        {'name': dep[1],
+                         'found': dep[0],
+                         "target": dep[4] + dep[5]})
+                    continue
+            elif dep[4].strip() == "<=":
+                if dep_version_int > high_check:
+                    d.append(
+                        {'name': dep[1],
+                         'found': dep[0],
+                         "target": dep[4] + dep[5]})
+                    continue
+    return d
@@ -16,7 +16,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
 import zipfile
 from lxml import etree
@@ -26,6 +25,7 @@ from .helper import split_authors
 from .constants import BookMeta


+
 def extractCover(zipFile, coverFile, coverpath, tmp_file_name):
    if coverFile is None:
        return None
@@ -65,11 +65,11 @@ def get_epub_info(tmp_file_path, original_file_name, original_file_extension):
        tmp = p.xpath('dc:%s/text()' % s, namespaces=ns)
        if len(tmp) > 0:
            if s == 'creator':
-                epub_metadata[s] = ' & '.join(split_authors(p.xpath('dc:%s/text()' % s, namespaces=ns)))
+                epub_metadata[s] = ' & '.join(split_authors(tmp))
            elif s == 'subject':
-                epub_metadata[s] = ', '.join(p.xpath('dc:%s/text()' % s, namespaces=ns))
+                epub_metadata[s] = ', '.join(tmp)
            else:
-                epub_metadata[s] = p.xpath('dc:%s/text()' % s, namespaces=ns)[0]
+                epub_metadata[s] = tmp[0]
        else:
            epub_metadata[s] = u'Unknown'

@@ -86,18 +86,29 @@ def get_epub_info(tmp_file_path, original_file_name, original_file_extension):
    lang = epub_metadata['language'].split('-', 1)[0].lower()
    epub_metadata['language'] = isoLanguages.get_lang3(lang)

-    series = tree.xpath("/pkg:package/pkg:metadata/pkg:meta[@name='calibre:series']/@content", namespaces=ns)
-    if len(series) > 0:
-        epub_metadata['series'] = series[0]
-    else:
-        epub_metadata['series'] = ''
+    epub_metadata = parse_epbub_series(ns, tree, epub_metadata)

-    series_id = tree.xpath("/pkg:package/pkg:metadata/pkg:meta[@name='calibre:series_index']/@content", namespaces=ns)
-    if len(series_id) > 0:
-        epub_metadata['series_id'] = series_id[0]
-    else:
-        epub_metadata['series_id'] = '1'
+    coverfile = parse_ebpub_cover(ns, tree, epubZip, coverpath, tmp_file_path)

+    if not epub_metadata['title']:
+        title = original_file_name
+    else:
+        title = epub_metadata['title']
+
+    return BookMeta(
+        file_path=tmp_file_path,
+        extension=original_file_extension,
+        title=title.encode('utf-8').decode('utf-8'),
+        author=epub_metadata['creator'].encode('utf-8').decode('utf-8'),
+        cover=coverfile,
+        description=epub_metadata['description'],
+        tags=epub_metadata['subject'].encode('utf-8').decode('utf-8'),
+        series=epub_metadata['series'].encode('utf-8').decode('utf-8'),
+        series_id=epub_metadata['series_id'].encode('utf-8').decode('utf-8'),
+        languages=epub_metadata['language'],
+        publisher="")
+
+def parse_ebpub_cover(ns, tree, epubZip, coverpath, tmp_file_path):
    coversection = tree.xpath("/pkg:package/pkg:manifest/pkg:item[@id='cover-image']/@href", namespaces=ns)
    coverfile = None
    if len(coversection) > 0:
@@ -125,20 +136,18 @@ def get_epub_info(tmp_file_path, original_file_name, original_file_extension):
                    coverfile = extractCover(epubZip, filename, "", tmp_file_path)
            else:
                coverfile = extractCover(epubZip, coversection[0], coverpath, tmp_file_path)
+    return coverfile

-    if not epub_metadata['title']:
-        title = original_file_name
+def parse_epbub_series(ns, tree, epub_metadata):
+    series = tree.xpath("/pkg:package/pkg:metadata/pkg:meta[@name='calibre:series']/@content", namespaces=ns)
+    if len(series) > 0:
+        epub_metadata['series'] = series[0]
    else:
-        title = epub_metadata['title']
+        epub_metadata['series'] = ''

-    return BookMeta(
-        file_path=tmp_file_path,
-        extension=original_file_extension,
-        title=title.encode('utf-8').decode('utf-8'),
-        author=epub_metadata['creator'].encode('utf-8').decode('utf-8'),
-        cover=coverfile,
-        description=epub_metadata['description'],
-        tags=epub_metadata['subject'].encode('utf-8').decode('utf-8'),
-        series=epub_metadata['series'].encode('utf-8').decode('utf-8'),
-        series_id=epub_metadata['series_id'].encode('utf-8').decode('utf-8'),
-        languages=epub_metadata['language'])
+    series_id = tree.xpath("/pkg:package/pkg:metadata/pkg:meta[@name='calibre:series_index']/@content", namespaces=ns)
+    if len(series_id) > 0:
+        epub_metadata['series_id'] = series_id[0]
+    else:
+        epub_metadata['series_id'] = '1'
+    return epub_metadata
@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2018-2020 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import traceback
+from flask import render_template
+from werkzeug.exceptions import default_exceptions
+try:
+    from werkzeug.exceptions import FailedDependency
+except ImportError:
+    from werkzeug.exceptions import UnprocessableEntity as FailedDependency
+
+from . import config, app, logger, services
+
+
+log = logger.create()
+
+# custom error page
+def error_http(error):
+    return render_template('http_error.html',
+                           error_code="Error {0}".format(error.code),
+                           error_name=error.name,
+                           issue=False,
+                           unconfigured=not config.db_configured,
+                           instance=config.config_calibre_web_title
+                           ), error.code
+
+
+def internal_error(error):
+    return render_template('http_error.html',
+                           error_code="Internal Server Error",
+                           error_name=str(error),
+                           issue=True,
+                           unconfigured=False,
+                           error_stack=traceback.format_exc().split("\n"),
+                           instance=config.config_calibre_web_title
+                           ), 500
+
+def init_errorhandler():
+    # http error handling
+    for ex in default_exceptions:
+        if ex < 500:
+            app.register_error_handler(ex, error_http)
+        elif ex == 500:
+            app.register_error_handler(ex, internal_error)
+
+
+    if services.ldap:
+        # Only way of catching the LDAPException upon logging in with LDAP server down
+        @app.errorhandler(services.ldap.LDAPException)
+        # pylint: disable=unused-variable
+        def handle_exception(e):
+            log.debug('LDAP server not accessible while trying to login to opds feed')
+            return error_http(FailedDependency())
+
@@ -16,7 +16,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 from lxml import etree

 from .constants import BookMeta
@@ -29,52 +28,53 @@ def get_fb2_info(tmp_file_path, original_file_extension):
        'l': 'http://www.w3.org/1999/xlink',
    }

-    fb2_file = open(tmp_file_path)
-    tree = etree.fromstring(fb2_file.read())
+    fb2_file = open(tmp_file_path, encoding="utf-8")
+    tree = etree.fromstring(fb2_file.read().encode())

    authors = tree.xpath('/fb:FictionBook/fb:description/fb:title-info/fb:author', namespaces=ns)

    def get_author(element):
        last_name = element.xpath('fb:last-name/text()', namespaces=ns)
        if len(last_name):
-            last_name = last_name[0].encode('utf-8')
+            last_name = last_name[0]
        else:
            last_name = u''
        middle_name = element.xpath('fb:middle-name/text()', namespaces=ns)
        if len(middle_name):
-            middle_name = middle_name[0].encode('utf-8')
+            middle_name = middle_name[0]
        else:
            middle_name = u''
        first_name = element.xpath('fb:first-name/text()', namespaces=ns)
        if len(first_name):
-            first_name = first_name[0].encode('utf-8')
+            first_name = first_name[0]
        else:
            first_name = u''
-        return (first_name.decode('utf-8') + u' '
-                + middle_name.decode('utf-8') + u' '
-                + last_name.decode('utf-8')).encode('utf-8')
+        return (first_name + u' '
+                + middle_name + u' '
+                + last_name)

    author = str(", ".join(map(get_author, authors)))

    title = tree.xpath('/fb:FictionBook/fb:description/fb:title-info/fb:book-title/text()', namespaces=ns)
    if len(title):
-        title = str(title[0].encode('utf-8'))
+        title = str(title[0])
    else:
        title = u''
    description = tree.xpath('/fb:FictionBook/fb:description/fb:publish-info/fb:book-name/text()', namespaces=ns)
    if len(description):
-        description = str(description[0].encode('utf-8'))
+        description = str(description[0])
    else:
        description = u''

    return BookMeta(
        file_path=tmp_file_path,
        extension=original_file_extension,
-        title=title.decode('utf-8'),
-        author=author.decode('utf-8'),
+        title=title,
+        author=author,
        cover=None,
-        description=description.decode('utf-8'),
+        description=description,
        tags="",
        series="",
        series_id="",
-        languages="")
+        languages="",
+        publisher="")
@@ -20,9 +20,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
-import sys
 import hashlib
 import json
 import tempfile
@@ -34,10 +32,10 @@ from flask import Blueprint, flash, request, redirect, url_for, abort
 from flask_babel import gettext as _
 from flask_login import login_required

-from . import logger, gdriveutils, config, ub, calibre_db
-from .web import admin_required
+from . import logger, gdriveutils, config, ub, calibre_db, csrf
+from .admin import admin_required

-gdrive = Blueprint('gdrive', __name__)
+gdrive = Blueprint('gdrive', __name__, url_prefix='/gdrive')
 log = logger.create()

 try:
@@ -47,10 +45,10 @@ except ImportError as err:

 current_milli_time = lambda: int(round(time() * 1000))

-gdrive_watch_callback_token = 'target=calibreweb-watch_files'
+gdrive_watch_callback_token = 'target=calibreweb-watch_files'  #nosec


-@gdrive.route("/gdrive/authenticate")
+@gdrive.route("/authenticate")
@login_required
@admin_required
 def authenticate_google_drive():
@@ -63,7 +61,7 @@ def authenticate_google_drive():
    return redirect(authUrl)


-@gdrive.route("/gdrive/callback")
+@gdrive.route("/callback")
 def google_drive_callback():
    auth_code = request.args.get('code')
    if not auth_code:
@@ -74,21 +72,17 @@ def google_drive_callback():
            f.write(credentials.to_json())
    except (ValueError, AttributeError) as error:
        log.error(error)
-    return redirect(url_for('admin.configuration'))
+    return redirect(url_for('admin.db_configuration'))


-@gdrive.route("/gdrive/watch/subscribe")
+@gdrive.route("/watch/subscribe")
@login_required
@admin_required
 def watch_gdrive():
    if not config.config_google_drive_watch_changes_response:
        with open(gdriveutils.CLIENT_SECRETS, 'r') as settings:
            filedata = json.load(settings)
-        if filedata['web']['redirect_uris'][0].endswith('/'):
-            filedata['web']['redirect_uris'][0] = filedata['web']['redirect_uris'][0][:-((len('/gdrive/callback')+1))]
-        else:
-            filedata['web']['redirect_uris'][0] = filedata['web']['redirect_uris'][0][:-(len('/gdrive/callback'))]
-        address = '%s/gdrive/watch/callback' % filedata['web']['redirect_uris'][0]
+        address = filedata['web']['redirect_uris'][0].rstrip('/').replace('/gdrive/callback', '/gdrive/watch/callback')
        notification_id = str(uuid4())
        try:
            result = gdriveutils.watchChange(gdriveutils.Gdrive.Instance().drive, notification_id,
@@ -98,14 +92,15 @@ def watch_gdrive():
        except HttpError as e:
            reason=json.loads(e.content)['error']['errors'][0]
            if reason['reason'] == u'push.webhookUrlUnauthorized':
-                flash(_(u'Callback domain is not verified, please follow steps to verify domain in google developer console'), category="error")
+                flash(_(u'Callback domain is not verified, '
+                        u'please follow steps to verify domain in google developer console'), category="error")
            else:
                flash(reason['message'], category="error")

-    return redirect(url_for('admin.configuration'))
+    return redirect(url_for('admin.db_configuration'))


-@gdrive.route("/gdrive/watch/revoke")
+@gdrive.route("/watch/revoke")
@login_required
@admin_required
 def revoke_watch_gdrive():
@@ -114,47 +109,50 @@ def revoke_watch_gdrive():
        try:
            gdriveutils.stopChannel(gdriveutils.Gdrive.Instance().drive, last_watch_response['id'],
                                    last_watch_response['resourceId'])
-        except HttpError:
+        except (HttpError, AttributeError):
            pass
        config.config_google_drive_watch_changes_response = {}
        config.save()
-    return redirect(url_for('admin.configuration'))
+    return redirect(url_for('admin.db_configuration'))

+try:
+    @csrf.exempt
+    @gdrive.route("/watch/callback", methods=['GET', 'POST'])
+    def on_received_watch_confirmation():
+        if not config.config_google_drive_watch_changes_response:
+            return ''
+        if request.headers.get('X-Goog-Channel-Token') != gdrive_watch_callback_token \
+                or request.headers.get('X-Goog-Resource-State') != 'change' \
+                or not request.data:
+            return ''

-@gdrive.route("/gdrive/watch/callback", methods=['GET', 'POST'])
-def on_received_watch_confirmation():
-    log.debug('%r', request.headers)
-    if request.headers.get('X-Goog-Channel-Token') == gdrive_watch_callback_token \
-            and request.headers.get('X-Goog-Resource-State') == 'change' \
-            and request.data:
+        log.debug('%r', request.headers)
+        log.debug('%r', request.data)
+        log.info('Change received from gdrive')

-        data = request.data
+        try:
+            j = json.loads(request.data)
+            log.info('Getting change details')
+            response = gdriveutils.getChangeById(gdriveutils.Gdrive.Instance().drive, j['id'])
+            log.debug('%r', response)
+            if response:
+                dbpath = os.path.join(config.config_calibre_dir, "metadata.db").encode()
+                if not response['deleted'] and response['file']['title'] == 'metadata.db' \
+                    and response['file']['md5Checksum'] != hashlib.md5(dbpath):  # nosec
+                    tmp_dir = os.path.join(tempfile.gettempdir(), 'calibre_web')
+                    if not os.path.isdir(tmp_dir):
+                        os.mkdir(tmp_dir)

-        def updateMetaData():
-            log.info('Change received from gdrive')
-            log.debug('%r', data)
-            try:
-                j = json.loads(data)
-                log.info('Getting change details')
-                response = gdriveutils.getChangeById(gdriveutils.Gdrive.Instance().drive, j['id'])
-                log.debug('%r', response)
-                if response:
-                    if sys.version_info < (3, 0):
-                        dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
-                    else:
-                        dbpath = os.path.join(config.config_calibre_dir, "metadata.db").encode()
-                    if not response['deleted'] and response['file']['title'] == 'metadata.db' \
-                       and response['file']['md5Checksum'] != hashlib.md5(dbpath):
-                        tmpDir = tempfile.gettempdir()
-                        log.info('Database file updated')
-                        copyfile(dbpath, os.path.join(tmpDir, "metadata.db_" + str(current_milli_time())))
-                        log.info('Backing up existing and downloading updated metadata.db')
-                        gdriveutils.downloadFile(None, "metadata.db", os.path.join(tmpDir, "tmp_metadata.db"))
-                        log.info('Setting up new DB')
-                        # prevent error on windows, as os.rename does on exisiting files
-                        move(os.path.join(tmpDir, "tmp_metadata.db"), dbpath)
-                        calibre_db.reconnect_db(config, ub.app_DB_path)
-            except Exception as e:
-                log.exception(e)
-        updateMetaData()
-    return ''
+                    log.info('Database file updated')
+                    copyfile(dbpath, os.path.join(tmp_dir, "metadata.db_" + str(current_milli_time())))
+                    log.info('Backing up existing and downloading updated metadata.db')
+                    gdriveutils.downloadFile(None, "metadata.db", os.path.join(tmp_dir, "tmp_metadata.db"))
+                    log.info('Setting up new DB')
+                    # prevent error on windows, as os.rename does on existing files, also allow cross hdd move
+                    move(os.path.join(tmp_dir, "tmp_metadata.db"), dbpath)
+                    calibre_db.reconnect_db(config, ub.app_DB_path)
+        except Exception as ex:
+            log.debug_or_exception(ex)
+        return ''
+except AttributeError:
+    pass
@@ -16,30 +16,56 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
 import json
 import shutil
+import chardet
+import ssl

 from flask import Response, stream_with_context
 from sqlalchemy import create_engine
 from sqlalchemy import Column, UniqueConstraint
 from sqlalchemy import String, Integer
 from sqlalchemy.orm import sessionmaker, scoped_session
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    # Compatibility with sqlalchemy 2.0
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.exc import OperationalError, InvalidRequestError
+from sqlalchemy.sql.expression import text
+
+try:
+    from six import __version__ as six_version
+except ImportError:
+    six_version = "not installed"
+try:
+    from httplib2 import __version__ as httplib2_version
+except ImportError:
+    httplib2_version = "not installed"

 try:
-    from pydrive.auth import GoogleAuth
-    from pydrive.drive import GoogleDrive
-    from pydrive.auth import RefreshError
    from apiclient import errors
    from httplib2 import ServerNotFoundError
-    gdrive_support = True
    importError = None
-except ImportError as err:
-    importError = err
+    gdrive_support = True
+except ImportError as e:
+    importError = e
    gdrive_support = False
+try:
+    from pydrive2.auth import GoogleAuth
+    from pydrive2.drive import GoogleDrive
+    from pydrive2.auth import RefreshError
+    from pydrive2.files import ApiRequestError
+except ImportError as err:
+    try:
+        from pydrive.auth import GoogleAuth
+        from pydrive.drive import GoogleDrive
+        from pydrive.auth import RefreshError
+        from pydrive.files import ApiRequestError
+    except ImportError as err:
+        importError = err
+        gdrive_support = False

 from . import logger, cli, config
 from .constants import CONFIG_DIR as _CONFIG_DIR
@@ -89,7 +115,7 @@ class Singleton:
        except AttributeError:
            self._instance = self._decorated()
            return self._instance
-        except ImportError as e:
+        except (ImportError, NameError) as e:
            log.debug(e)
            return None

@@ -153,7 +179,7 @@ class PermissionAdded(Base):
 def migrate():
    if not engine.dialect.has_table(engine.connect(), "permissions_added"):
        PermissionAdded.__table__.create(bind = engine)
-    for sql in session.execute("select sql from sqlite_master where type='table'"):
+    for sql in session.execute(text("select sql from sqlite_master where type='table'")):
        if 'CREATE TABLE gdrive_ids' in sql[0]:
            currUniqueConstraint = 'UNIQUE (gdrive_id)'
            if currUniqueConstraint in sql[0]:
@@ -187,8 +213,8 @@ def getDrive(drive=None, gauth=None):
                gauth.Refresh()
            except RefreshError as e:
                log.error("Google Drive error: %s", e)
-            except Exception as e:
-                log.exception(e)
+            except Exception as ex:
+                log.debug_or_exception(ex)
        else:
            # Initialize the saved creds
            gauth.Authorize()
@@ -206,7 +232,7 @@ def listRootFolders():
        drive = getDrive(Gdrive.Instance().drive)
        folder = "'root' in parents and mimeType = 'application/vnd.google-apps.folder' and trashed = false"
        fileList = drive.ListFile({'q': folder}).GetList()
-    except ServerNotFoundError as e:
+    except (ServerNotFoundError, ssl.SSLError, RefreshError) as e:
        log.info("GDrive Error %s" % e)
        fileList = []
    return fileList
@@ -242,7 +268,12 @@ def getEbooksFolderId(drive=None):
            log.error('Error gDrive, root ID not found')
        gDriveId.path = '/'
        session.merge(gDriveId)
-        session.commit()
+        try:
+            session.commit()
+        except OperationalError as ex:
+            log.error("gdrive.db DB is not Writeable")
+            log.debug('Database error: %s', ex)
+            session.rollback()
        return gDriveId.gdrive_id


@@ -257,37 +288,47 @@ def getFile(pathId, fileName, drive):

 def getFolderId(path, drive):
    # drive = getDrive(drive)
-    currentFolderId = getEbooksFolderId(drive)
-    sqlCheckPath = path if path[-1] == '/' else path + '/'
-    storedPathName = session.query(GdriveId).filter(GdriveId.path == sqlCheckPath).first()
+    try:
+        currentFolderId = getEbooksFolderId(drive)
+        sqlCheckPath = path if path[-1] == '/' else path + '/'
+        storedPathName = session.query(GdriveId).filter(GdriveId.path == sqlCheckPath).first()

-    if not storedPathName:
-        dbChange = False
-        s = path.split('/')
-        for i, x in enumerate(s):
-            if len(x) > 0:
-                currentPath = "/".join(s[:i+1])
-                if currentPath[-1] != '/':
-                    currentPath = currentPath + '/'
-                storedPathName = session.query(GdriveId).filter(GdriveId.path == currentPath).first()
-                if storedPathName:
-                    currentFolderId = storedPathName.gdrive_id
-                else:
-                    currentFolder = getFolderInFolder(currentFolderId, x, drive)
-                    if currentFolder:
-                        gDriveId = GdriveId()
-                        gDriveId.gdrive_id = currentFolder['id']
-                        gDriveId.path = currentPath
-                        session.merge(gDriveId)
-                        dbChange = True
-                        currentFolderId = currentFolder['id']
+        if not storedPathName:
+            dbChange = False
+            s = path.split('/')
+            for i, x in enumerate(s):
+                if len(x) > 0:
+                    currentPath = "/".join(s[:i+1])
+                    if currentPath[-1] != '/':
+                        currentPath = currentPath + '/'
+                    storedPathName = session.query(GdriveId).filter(GdriveId.path == currentPath).first()
+                    if storedPathName:
+                        currentFolderId = storedPathName.gdrive_id
                    else:
-                        currentFolderId = None
-                        break
-        if dbChange:
-            session.commit()
-    else:
-        currentFolderId = storedPathName.gdrive_id
+                        currentFolder = getFolderInFolder(currentFolderId, x, drive)
+                        if currentFolder:
+                            gDriveId = GdriveId()
+                            gDriveId.gdrive_id = currentFolder['id']
+                            gDriveId.path = currentPath
+                            session.merge(gDriveId)
+                            dbChange = True
+                            currentFolderId = currentFolder['id']
+                        else:
+                            currentFolderId = None
+                            break
+            if dbChange:
+                session.commit()
+        else:
+            currentFolderId = storedPathName.gdrive_id
+    except OperationalError as ex:
+        log.error("gdrive.db DB is not Writeable")
+        log.debug('Database error: %s', ex)
+        session.rollback()
+    except ApiRequestError as ex:
+        log.error('{} {}'.format(ex.error['message'], path))
+        session.rollback()
+    except RefreshError as ex:
+        log.error(ex)
    return currentFolderId


@@ -331,7 +372,7 @@ def moveGdriveFolderRemote(origin_file, target_folder):
                                      addParents=gFileTargetDir['id'],
                                      removeParents=previous_parents,
                                      fields='id, parents').execute()
-    # if previous_parents has no childs anymore, delete original fileparent
+    # if previous_parents has no children anymore, delete original fileparent
    if len(children['items']) == 1:
        deleteDatabaseEntry(previous_parents)
        drive.auth.service.files().delete(fileId=previous_parents).execute()
@@ -383,7 +424,8 @@ def uploadFileToEbooksFolder(destFile, f):
            if len(existingFiles) > 0:
                driveFile = existingFiles[0]
            else:
-                driveFile = drive.CreateFile({'title': x, 'parents': [{"kind": "drive#fileLink", 'id': parent['id']}],})
+                driveFile = drive.CreateFile({'title': x,
+                                              'parents': [{"kind": "drive#fileLink", 'id': parent['id']}], })
            driveFile.SetContentFile(f)
            driveFile.Upload()
        else:
@@ -481,8 +523,8 @@ def getChangeById (drive, change_id):
    except (errors.HttpError) as error:
        log.error(error)
        return None
-    except Exception as e:
-        log.error(e)
+    except Exception as ex:
+        log.error(ex)
        return None


@@ -491,9 +533,10 @@ def deleteDatabaseOnChange():
    try:
        session.query(GdriveId).delete()
        session.commit()
-    except (OperationalError, InvalidRequestError):
+    except (OperationalError, InvalidRequestError) as ex:
        session.rollback()
-        log.info(u"GDrive DB is not Writeable")
+        log.debug('Database error: %s', ex)
+        log.error(u"GDrive DB is not Writeable")


 def updateGdriveCalibreFromLocal():
@@ -508,13 +551,23 @@ def updateDatabaseOnEdit(ID,newPath):
    storedPathName = session.query(GdriveId).filter(GdriveId.gdrive_id == ID).first()
    if storedPathName:
        storedPathName.path = sqlCheckPath
-        session.commit()
+        try:
+            session.commit()
+        except OperationalError as ex:
+            log.error("gdrive.db DB is not Writeable")
+            log.debug('Database error: %s', ex)
+            session.rollback()


 # Deletes the hashes in database of deleted book
 def deleteDatabaseEntry(ID):
    session.query(GdriveId).filter(GdriveId.gdrive_id == ID).delete()
-    session.commit()
+    try:
+        session.commit()
+    except OperationalError as ex:
+        log.error("gdrive.db DB is not Writeable")
+        log.debug('Database error: %s', ex)
+        session.rollback()


 # Gets cover file from gdrive
@@ -531,7 +584,12 @@ def get_cover_via_gdrive(cover_path):
            permissionAdded = PermissionAdded()
            permissionAdded.gdrive_id = df['id']
            session.add(permissionAdded)
-            session.commit()
+            try:
+                session.commit()
+            except OperationalError as ex:
+                log.error("gdrive.db DB is not Writeable")
+                log.debug('Database error: %s', ex)
+                session.rollback()
        return df.metadata.get('webContentLink')
    else:
        return None
@@ -545,21 +603,24 @@ def partial(total_byte_len, part_size_limit):
    return s

 # downloads files in chunks from gdrive
-def do_gdrive_download(df, headers):
+def do_gdrive_download(df, headers, convert_encoding=False):
    total_size = int(df.metadata.get('fileSize'))
    download_url = df.metadata.get('downloadUrl')
    s = partial(total_size, 1024 * 1024)  # I'm downloading BIG files, so 100M chunk size is fine for me

-    def stream():
+    def stream(convert_encoding):
        for byte in s:
            headers = {"Range": 'bytes=%s-%s' % (byte[0], byte[1])}
            resp, content = df.auth.Get_Http_Object().request(download_url, headers=headers)
            if resp.status == 206:
+                if convert_encoding:
+                    result = chardet.detect(content)
+                    content = content.decode(result['encoding']).encode('utf-8')
                yield content
            else:
                log.warning('An error occurred: %s', resp)
                return
-    return Response(stream_with_context(stream()), headers=headers)
+    return Response(stream_with_context(stream(convert_encoding)), headers=headers)


 _SETTINGS_YAML_TEMPLATE = """
@@ -614,3 +675,8 @@ def get_error_text(client_secrets=None):
        return 'Callback url (redirect url) is missing in client_secrets.json'
    if client_secrets:
        client_secrets.update(filedata['web'])
+
+
+def get_versions():
+    return {'six': six_version,
+            'httplib2': httplib2_version}
@@ -17,33 +17,28 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
-import sys
 import os
 import io
 import mimetypes
 import re
 import shutil
-import time
+import socket
 import unicodedata
 from datetime import datetime, timedelta
 from tempfile import gettempdir
-
+from urllib.parse import urlparse
 import requests
+
 from babel.dates import format_datetime
 from babel.units import format_unit
-from flask import send_from_directory, make_response, redirect, abort
+from flask import send_from_directory, make_response, redirect, abort, url_for
 from flask_babel import gettext as _
 from flask_login import current_user
 from sqlalchemy.sql.expression import true, false, and_, text, func
 from werkzeug.datastructures import Headers
 from werkzeug.security import generate_password_hash
-from . import calibre_db
-
-try:
-    from urllib.parse import quote
-except ImportError:
-    from urllib import quote
+from markupsafe import escape
+from urllib.parse import quote

 try:
    import unidecode
@@ -51,140 +46,135 @@ try:
 except ImportError:
    use_unidecode = False

-try:
-    from PIL import Image as PILImage
-    from PIL import UnidentifiedImageError
-    use_PIL = True
-except ImportError:
-    use_PIL = False
-
-from . import logger, config, get_locale, db, ub, worker
+from . import calibre_db, cli
+from .tasks.convert import TaskConvert
+from . import logger, config, get_locale, db, ub
 from . import gdriveutils as gd
 from .constants import STATIC_DIR as _STATIC_DIR
 from .subproc_wrapper import process_wait
-from .worker import STAT_WAITING, STAT_FAIL, STAT_STARTED, STAT_FINISH_SUCCESS
-from .worker import TASK_EMAIL, TASK_CONVERT, TASK_UPLOAD, TASK_CONVERT_ANY
-
+from .services.worker import WorkerThread, STAT_WAITING, STAT_FAIL, STAT_STARTED, STAT_FINISH_SUCCESS
+from .tasks.mail import TaskEmail

 log = logger.create()

+try:
+    from wand.image import Image
+    from wand.exceptions import MissingDelegateError, BlobError
+    use_IM = True
+except (ImportError, RuntimeError) as e:
+    log.debug('Cannot import Image, generating covers from non jpg files will not work: %s', e)
+    use_IM = False
+    MissingDelegateError = BaseException
+

 # Convert existing book entry to new format
 def convert_book_format(book_id, calibrepath, old_book_format, new_book_format, user_id, kindle_mail=None):
    book = calibre_db.get_book(book_id)
    data = calibre_db.get_book_format(book.id, old_book_format)
+    file_path = os.path.join(calibrepath, book.path, data.name)
    if not data:
        error_message = _(u"%(format)s format not found for book id: %(book)d", format=old_book_format, book=book_id)
        log.error("convert_book_format: %s", error_message)
        return error_message
    if config.config_use_google_drive:
-        df = gd.getFileFromEbooksFolder(book.path, data.name + "." + old_book_format.lower())
-        if df:
-            datafile = os.path.join(calibrepath, book.path, data.name + u"." + old_book_format.lower())
-            if not os.path.exists(os.path.join(calibrepath, book.path)):
-                os.makedirs(os.path.join(calibrepath, book.path))
-            df.GetContentFile(datafile)
-        else:
+        if not gd.getFileFromEbooksFolder(book.path, data.name + "." + old_book_format.lower()):
            error_message = _(u"%(format)s not found on Google Drive: %(fn)s",
                              format=old_book_format, fn=data.name + "." + old_book_format.lower())
            return error_message
-    file_path = os.path.join(calibrepath, book.path, data.name)
-    if os.path.exists(file_path + "." + old_book_format.lower()):
-        # read settings and append converter task to queue
-        if kindle_mail:
-            settings = config.get_mail_settings()
-            settings['subject'] = _('Send to Kindle')  # pretranslate Subject for e-mail
-            settings['body'] = _(u'This e-mail has been sent via Calibre-Web.')
-            # text = _(u"%(format)s: %(book)s", format=new_book_format, book=book.title)
-        else:
-            settings = dict()
-        txt = (u"%s -> %s: %s" % (old_book_format, new_book_format, book.title))
-        settings['old_book_format'] = old_book_format
-        settings['new_book_format'] = new_book_format
-        worker.add_convert(file_path, book.id, user_id, txt, settings, kindle_mail)
-        return None
    else:
-        error_message = _(u"%(format)s not found: %(fn)s",
-                          format=old_book_format, fn=data.name + "." + old_book_format.lower())
-        return error_message
+        if not os.path.exists(file_path + "." + old_book_format.lower()):
+            error_message = _(u"%(format)s not found: %(fn)s",
+                              format=old_book_format, fn=data.name + "." + old_book_format.lower())
+            return error_message
+    # read settings and append converter task to queue
+    if kindle_mail:
+        settings = config.get_mail_settings()
+        settings['subject'] = _('Send to Kindle')  # pretranslate Subject for e-mail
+        settings['body'] = _(u'This e-mail has been sent via Calibre-Web.')
+    else:
+        settings = dict()
+    link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book.id), escape(book.title))  # prevent xss
+    txt = u"{} -> {}: {}".format(
+           old_book_format.upper(),
+           new_book_format.upper(),
+           link)
+    settings['old_book_format'] = old_book_format
+    settings['new_book_format'] = new_book_format
+    WorkerThread.add(user_id, TaskConvert(file_path, book.id, txt, settings, kindle_mail, user_id))
+    return None


 def send_test_mail(kindle_mail, user_name):
-    worker.add_email(_(u'Calibre-Web test e-mail'), None, None,
-                     config.get_mail_settings(), kindle_mail, user_name,
-                     _(u"Test e-mail"), _(u'This e-mail has been sent via Calibre-Web.'))
+    WorkerThread.add(user_name, TaskEmail(_(u'Calibre-Web test e-mail'), None, None,
+                     config.get_mail_settings(), kindle_mail, _(u"Test e-mail"),
+                                          _(u'This e-mail has been sent via Calibre-Web.')))
    return


 # Send registration email or password reset email, depending on parameter resend (False means welcome email)
 def send_registration_mail(e_mail, user_name, default_password, resend=False):
-    text = "Hello %s!\r\n" % user_name
+    txt = "Hello %s!\r\n" % user_name
    if not resend:
-        text += "Your new account at Calibre-Web has been created. Thanks for joining us!\r\n"
-    text += "Please log in to your account using the following informations:\r\n"
-    text += "User name: %s\r\n" % user_name
-    text += "Password: %s\r\n" % default_password
-    text += "Don't forget to change your password after first login.\r\n"
-    text += "Sincerely\r\n\r\n"
-    text += "Your Calibre-Web team"
-    worker.add_email(_(u'Get Started with Calibre-Web'), None, None,
-                     config.get_mail_settings(), e_mail, None,
-                     _(u"Registration e-mail for user: %(name)s", name=user_name), text)
+        txt += "Your new account at Calibre-Web has been created. Thanks for joining us!\r\n"
+    txt += "Please log in to your account using the following informations:\r\n"
+    txt += "User name: %s\r\n" % user_name
+    txt += "Password: %s\r\n" % default_password
+    txt += "Don't forget to change your password after first login.\r\n"
+    txt += "Sincerely\r\n\r\n"
+    txt += "Your Calibre-Web team"
+    WorkerThread.add(None, TaskEmail(
+        subject=_(u'Get Started with Calibre-Web'),
+        filepath=None,
+        attachment=None,
+        settings=config.get_mail_settings(),
+        recipient=e_mail,
+        taskMessage=_(u"Registration e-mail for user: %(name)s", name=user_name),
+        text=txt
+    ))
    return


+def check_send_to_kindle_with_converter(formats):
+    bookformats = list()
+    if 'EPUB' in formats and 'MOBI' not in formats:
+        bookformats.append({'format': 'Mobi',
+                            'convert': 1,
+                            'text': _('Convert %(orig)s to %(format)s and send to Kindle',
+                                      orig='Epub',
+                                      format='Mobi')})
+    if 'AZW3' in formats and not 'MOBI' in formats:
+        bookformats.append({'format': 'Mobi',
+                            'convert': 2,
+                            'text': _('Convert %(orig)s to %(format)s and send to Kindle',
+                                      orig='Azw3',
+                                      format='Mobi')})
+    return bookformats
+
+
 def check_send_to_kindle(entry):
    """
        returns all available book formats for sending to Kindle
    """
+    formats = list()
+    bookformats = list()
    if len(entry.data):
-        bookformats = list()
-        if not config.config_converterpath:
-            # no converter - only for mobi and pdf formats
-            for ele in iter(entry.data):
-                if ele.uncompressed_size < config.mail_size:
-                    if 'MOBI' in ele.format:
-                        bookformats.append({'format': 'Mobi',
-                                            'convert': 0,
-                                            'text': _('Send %(format)s to Kindle', format='Mobi')})
-                    if 'PDF' in ele.format:
-                        bookformats.append({'format': 'Pdf',
-                                            'convert': 0,
-                                            'text': _('Send %(format)s to Kindle', format='Pdf')})
-                    if 'AZW' in ele.format:
-                        bookformats.append({'format': 'Azw',
-                                            'convert': 0,
-                                            'text': _('Send %(format)s to Kindle', format='Azw')})
-        else:
-            formats = list()
-            for ele in iter(entry.data):
-                if ele.uncompressed_size < config.mail_size:
-                    formats.append(ele.format)
-            if 'MOBI' in formats:
-                bookformats.append({'format': 'Mobi',
-                                    'convert': 0,
-                                    'text': _('Send %(format)s to Kindle', format='Mobi')})
-            if 'AZW' in formats:
-                bookformats.append({'format': 'Azw',
-                                    'convert': 0,
-                                    'text': _('Send %(format)s to Kindle', format='Azw')})
-            if 'PDF' in formats:
-                bookformats.append({'format': 'Pdf',
-                                    'convert': 0,
-                                    'text': _('Send %(format)s to Kindle', format='Pdf')})
-            if config.config_converterpath:
-                if 'EPUB' in formats and not 'MOBI' in formats:
-                    bookformats.append({'format': 'Mobi',
-                                        'convert':1,
-                                        'text': _('Convert %(orig)s to %(format)s and send to Kindle',
-                                                  orig='Epub',
-                                                  format='Mobi')})
-                if 'AZW3' in formats and not 'MOBI' in formats:
-                    bookformats.append({'format': 'Mobi',
-                                        'convert': 2,
-                                        'text': _('Convert %(orig)s to %(format)s and send to Kindle',
-                                                  orig='Azw3',
-                                                  format='Mobi')})
+        for ele in iter(entry.data):
+            if ele.uncompressed_size < config.mail_size:
+                formats.append(ele.format)
+        if 'MOBI' in formats:
+            bookformats.append({'format': 'Mobi',
+                                'convert': 0,
+                                'text': _('Send %(format)s to Kindle', format='Mobi')})
+        if 'PDF' in formats:
+            bookformats.append({'format': 'Pdf',
+                                'convert': 0,
+                                'text': _('Send %(format)s to Kindle', format='Pdf')})
+        if 'AZW' in formats:
+            bookformats.append({'format': 'Azw',
+                                'convert': 0,
+                                'text': _('Send %(format)s to Kindle', format='Azw')})
+        if config.config_converterpath:
+            bookformats.extend(check_send_to_kindle_with_converter(formats))
        return bookformats
    else:
        log.error(u'Cannot find book entry %d', entry.id)
@@ -194,7 +184,7 @@ def check_send_to_kindle(entry):
 # Check if a reader is existing for any of the book formats, if not, return empty list, otherwise return
 # list with supported formats
 def check_read_formats(entry):
-    EXTENSIONS_READER = {'TXT', 'PDF', 'EPUB', 'CBZ', 'CBT', 'CBR'}
+    EXTENSIONS_READER = {'TXT', 'PDF', 'EPUB', 'CBZ', 'CBT', 'CBR', 'DJVU'}
    bookformats = list()
    if len(entry.data):
        for ele in iter(entry.data):
@@ -221,9 +211,11 @@ def send_mail(book_id, book_format, convert, kindle_mail, calibrepath, user_id):
    for entry in iter(book.data):
        if entry.format.upper() == book_format.upper():
            converted_file_name = entry.name + '.' + book_format.lower()
-            worker.add_email(_(u"Send to Kindle"), book.path, converted_file_name,
-                             config.get_mail_settings(), kindle_mail, user_id,
-                             _(u"E-mail: %(book)s", book=book.title), _(u'This e-mail has been sent via Calibre-Web.'))
+            link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book_id), escape(book.title))
+            EmailText = _(u"%(book)s send to Kindle", book=link)
+            WorkerThread.add(user_id, TaskEmail(_(u"Send to Kindle"), book.path, converted_file_name,
+                             config.get_mail_settings(), kindle_mail,
+                             EmailText, _(u'This e-mail has been sent via Calibre-Web.')))
            return
    return _(u"The requested file could not be read. Maybe wrong permissions?")

@@ -237,16 +229,14 @@ def get_valid_filename(value, replace_whitespace=True):
        value = value[:-1]+u'_'
    value = value.replace("/", "_").replace(":", "_").strip('\0')
    if use_unidecode:
-        value = (unidecode.unidecode(value))
+        if config.config_unicode_filename:
+            value = (unidecode.unidecode(value))
    else:
        value = value.replace(u'§', u'SS')
        value = value.replace(u'ß', u'ss')
        value = unicodedata.normalize('NFKD', value)
        re_slugify = re.compile(r'[\W\s-]', re.UNICODE)
-        if isinstance(value, str):  # Python3 str, Python2 unicode
-            value = re_slugify.sub('', value)
-        else:
-            value = unicode(re_slugify.sub('', value))
+        value = re_slugify.sub('', value)
    if replace_whitespace:
        #  *+:\"/<>? are replaced by _
        value = re.sub(r'[*+:\\\"/<>?]+', u'_', value, flags=re.U)
@@ -255,10 +245,7 @@ def get_valid_filename(value, replace_whitespace=True):
    value = value[:128].strip()
    if not value:
        raise ValueError("Filename cannot be empty")
-    if sys.version_info.major == 3:
-        return value
-    else:
-        return value.decode('utf-8')
+    return value


 def split_authors(values):
@@ -336,73 +323,82 @@ def delete_book_file(book, calibrepath, book_format=None):
                    except (IOError, OSError) as e:
                        log.error("Deleting authorpath for book %s failed: %s", book.id, e)
                return True, None
-            else:
-                log.error("Deleting book %s failed, book path not valid: %s", book.id, book.path)
-                return True, _("Deleting book %(id)s, book path not valid: %(path)s",
-                               id=book.id,
-                               path=book.path)
+
+    log.error("Deleting book %s from database only, book path in database not valid: %s",
+              book.id, book.path)
+    return True, _("Deleting book %(id)s from database only, book path in database not valid: %(path)s",
+                   id=book.id,
+                   path=book.path)


-def update_dir_structure_file(book_id, calibrepath, first_author):
+# Moves files in file storage during author/title rename, or from temp dir to file storage
+def update_dir_structure_file(book_id, calibrepath, first_author, orignal_filepath, db_filename):
+    # get book database entry from id, if original path overwrite source with original_filepath
    localbook = calibre_db.get_book(book_id)
-    path = os.path.join(calibrepath, localbook.path)
+    if orignal_filepath:
+        path = orignal_filepath
+    else:
+        path = os.path.join(calibrepath, localbook.path)

+    # Create (current) authordir and titledir from database
    authordir = localbook.path.split('/')[0]
+    titledir = localbook.path.split('/')[1]
+
+    # Create new_authordir from parameter or from database
+    # Create new titledir from database and add id
    if first_author:
        new_authordir = get_valid_filename(first_author)
    else:
        new_authordir = get_valid_filename(localbook.authors[0].name)
-
-    titledir = localbook.path.split('/')[1]
    new_titledir = get_valid_filename(localbook.title) + " (" + str(book_id) + ")"

-    if titledir != new_titledir:
-        new_title_path = os.path.join(os.path.dirname(path), new_titledir)
+    if titledir != new_titledir or authordir != new_authordir or orignal_filepath:
+        new_path = os.path.join(calibrepath, new_authordir, new_titledir)
+        new_name = get_valid_filename(localbook.title) + ' - ' + get_valid_filename(new_authordir)
        try:
-            if not os.path.exists(new_title_path):
-                os.renames(os.path.normcase(path), os.path.normcase(new_title_path))
+            if orignal_filepath:
+                if not os.path.isdir(new_path):
+                    os.makedirs(new_path)
+                shutil.move(os.path.normcase(path), os.path.normcase(os.path.join(new_path, db_filename)))
+                log.debug("Moving title: %s to %s/%s", path, new_path, new_name)
+                # Check new path is not valid path
            else:
-                log.info("Copying title: %s into existing: %s", path, new_title_path)
-                for dir_name, __, file_list in os.walk(path):
-                    for file in file_list:
-                        os.renames(os.path.normcase(os.path.join(dir_name, file)),
-                                   os.path.normcase(os.path.join(new_title_path + dir_name[len(path):], file)))
-            path = new_title_path
-            localbook.path = localbook.path.split('/')[0] + '/' + new_titledir
-        except OSError as ex:
-            log.error("Rename title from: %s to %s: %s", path, new_title_path, ex)
+                if not os.path.exists(new_path):
+                    # move original path to new path
+                    log.debug("Moving title: %s to %s", path, new_path)
+                    shutil.move(os.path.normcase(path), os.path.normcase(new_path))
+                else: # path is valid copy only files to new location (merge)
+                    log.info("Moving title: %s into existing: %s", path, new_path)
+                    # Take all files and subfolder from old path (strange command)
+                    for dir_name, __, file_list in os.walk(path):
+                        for file in file_list:
+                            shutil.move(os.path.normcase(os.path.join(dir_name, file)),
+                                            os.path.normcase(os.path.join(new_path + dir_name[len(path):], file)))
+                            # os.unlink(os.path.normcase(os.path.join(dir_name, file)))
+            # change location in database to new author/title path
+            localbook.path = os.path.join(new_authordir, new_titledir).replace('\\','/')
+        except (OSError) as ex:
+            log.error("Rename title from: %s to %s: %s", path, new_path, ex)
            log.debug(ex, exc_info=True)
            return _("Rename title from: '%(src)s' to '%(dest)s' failed with error: %(error)s",
-                     src=path, dest=new_title_path, error=str(ex))
-    if authordir != new_authordir:
-        new_author_path = os.path.join(calibrepath, new_authordir, os.path.basename(path))
+                     src=path, dest=new_path, error=str(ex))
+
+        # Rename all files from old names to new names
        try:
-            os.renames(os.path.normcase(path), os.path.normcase(new_author_path))
-            localbook.path = new_authordir + '/' + localbook.path.split('/')[1]
-        except OSError as ex:
-            log.error("Rename author from: %s to %s: %s", path, new_author_path, ex)
-            log.debug(ex, exc_info=True)
-            return _("Rename author from: '%(src)s' to '%(dest)s' failed with error: %(error)s",
-                     src=path, dest=new_author_path, error=str(ex))
-    # Rename all files from old names to new names
-    if authordir != new_authordir or titledir != new_titledir:
-        new_name = ""
-        try:
-            new_name = get_valid_filename(localbook.title) + ' - ' + get_valid_filename(new_authordir)
-            path_name = os.path.join(calibrepath, new_authordir, os.path.basename(path))
            for file_format in localbook.data:
-                os.renames(os.path.normcase(
-                    os.path.join(path_name, file_format.name + '.' + file_format.format.lower())),
-                           os.path.normcase(os.path.join(path_name, new_name + '.' + file_format.format.lower())))
+                shutil.move(os.path.normcase(
+                    os.path.join(new_path, file_format.name + '.' + file_format.format.lower())),
+                    os.path.normcase(os.path.join(new_path, new_name + '.' + file_format.format.lower())))
                file_format.name = new_name
-        except OSError as ex:
-            log.error("Rename file in path %s to %s: %s", path, new_name, ex)
+            if not orignal_filepath and len(os.listdir(os.path.dirname(path))) == 0:
+                shutil.rmtree(os.path.dirname(path))
+        except (OSError) as ex:
+            log.error("Rename file in path %s to %s: %s", new_path, new_name, ex)
            log.debug(ex, exc_info=True)
            return _("Rename file in path '%(src)s' to '%(dest)s' failed with error: %(error)s",
-                     src=path, dest=new_name, error=str(ex))
+                     src=new_path, dest=new_name, error=str(ex))
    return False

-
 def update_dir_structure_gdrive(book_id, first_author):
    error = False
    book = calibre_db.get_book(book_id)
@@ -479,8 +475,8 @@ def reset_password(user_id):
        password = generate_random_password()
        existing_user.password = generate_password_hash(password)
        ub.session.commit()
-        send_registration_mail(existing_user.email, existing_user.nickname, password, True)
-        return 1, existing_user.nickname
+        send_registration_mail(existing_user.email, existing_user.name, password, True)
+        return 1, existing_user.name
    except Exception:
        ub.session.rollback()
        return 0, None
@@ -489,27 +485,50 @@ def reset_password(user_id):
 def generate_random_password():
    s = "abcdefghijklmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%&*()?"
    passlen = 8
-    if sys.version_info < (3, 0):
-        return "".join(s[ord(c) % len(s)] for c in os.urandom(passlen))
-    else:
-        return "".join(s[c % len(s)] for c in os.urandom(passlen))
+    return "".join(s[c % len(s)] for c in os.urandom(passlen))


 def uniq(inpt):
    output = []
+    inpt = [ " ".join(inp.split()) for inp in inpt]
    for x in inpt:
        if x not in output:
            output.append(x)
    return output

+def check_email(email):
+    email = valid_email(email)
+    if ub.session.query(ub.User).filter(func.lower(ub.User.email) == email.lower()).first():
+        log.error(u"Found an existing account for this e-mail address")
+        raise Exception(_(u"Found an existing account for this e-mail address"))
+    return email
+
+
+def check_username(username):
+    username = username.strip()
+    if ub.session.query(ub.User).filter(func.lower(ub.User.name) == username.lower()).scalar():
+        log.error(u"This username is already taken")
+        raise Exception (_(u"This username is already taken"))
+    return username
+
+
+def valid_email(email):
+    email = email.strip()
+    # Regex according to https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email#validation
+    if not re.search(r"^[\w.!#$%&'*+\\/=?^_`{|}~-]+@[\w](?:[\w-]{0,61}[\w])?(?:\.[\w](?:[\w-]{0,61}[\w])?)*$",
+                     email):
+        log.error(u"Invalid e-mail address format")
+        raise Exception(_(u"Invalid e-mail address format"))
+    return email
+
 # ################################# External interface #################################


-def update_dir_stucture(book_id, calibrepath, first_author=None):
+def update_dir_stucture(book_id, calibrepath, first_author=None, orignal_filepath=None, db_filename=None):
    if config.config_use_google_drive:
        return update_dir_structure_gdrive(book_id, first_author)
    else:
-        return update_dir_structure_file(book_id, calibrepath, first_author)
+        return update_dir_structure_file(book_id, calibrepath, first_author, orignal_filepath, db_filename)


 def delete_book(book, calibrepath, book_format):
@@ -549,9 +568,8 @@ def get_book_cover_internal(book, use_generic_cover_on_failure):
                else:
                    log.error('%s/cover.jpg not found on Google Drive', book.path)
                    return get_cover_on_failure(use_generic_cover_on_failure)
-            except Exception as e:
-                log.exception(e)
-                # traceback.print_exc()
+            except Exception as ex:
+                log.debug_or_exception(ex)
                return get_cover_on_failure(use_generic_cover_on_failure)
        else:
            cover_file_path = os.path.join(config.config_calibre_dir, book.path)
@@ -566,37 +584,50 @@ def get_book_cover_internal(book, use_generic_cover_on_failure):
 # saves book cover from url
 def save_cover_from_url(url, book_path):
    try:
+        if not cli.allow_localhost:
+            # 127.0.x.x, localhost, [::1], [::ffff:7f00:1]
+            ip = socket.getaddrinfo(urlparse(url).hostname, 0)[0][4][0]
+            if ip.startswith("127.") or ip.startswith('::ffff:7f') or ip == "::1":
+                log.error("Localhost was accessed for cover upload")
+                return False, _("You are not allowed to access localhost for cover uploads")
        img = requests.get(url, timeout=(10, 200))      # ToDo: Error Handling
        img.raise_for_status()
        return save_cover(img, book_path)
-    except (requests.exceptions.HTTPError,
+    except (socket.gaierror,
+            requests.exceptions.HTTPError,
            requests.exceptions.ConnectionError,
            requests.exceptions.Timeout) as ex:
        log.info(u'Cover Download Error %s', ex)
        return False, _("Error Downloading Cover")
-    except UnidentifiedImageError as ex:
+    except MissingDelegateError as ex:
        log.info(u'File Format Error %s', ex)
        return False, _("Cover Format Error")


 def save_cover_from_filestorage(filepath, saved_filename, img):
-    if hasattr(img, '_content'):
-        f = open(os.path.join(filepath, saved_filename), "wb")
-        f.write(img._content)
-        f.close()
-    else:
-        # check if file path exists, otherwise create it, copy file to calibre path and delete temp file
-        if not os.path.exists(filepath):
-            try:
-                os.makedirs(filepath)
-            except OSError:
-                log.error(u"Failed to create path for cover")
-                return False, _(u"Failed to create path for cover")
+    # check if file path exists, otherwise create it, copy file to calibre path and delete temp file
+    if not os.path.exists(filepath):
        try:
-            img.save(os.path.join(filepath, saved_filename))
-        except (IOError, OSError):
-            log.error(u"Cover-file is not a valid image file, or could not be stored")
-            return False, _(u"Cover-file is not a valid image file, or could not be stored")
+            os.makedirs(filepath)
+        except OSError:
+            log.error(u"Failed to create path for cover")
+            return False, _(u"Failed to create path for cover")
+    try:
+        # upload of jgp file without wand
+        if isinstance(img, requests.Response):
+            with open(os.path.join(filepath, saved_filename), 'wb') as f:
+                f.write(img.content)
+        else:
+            if hasattr(img, "metadata"):
+                # upload of jpg/png... via url
+                img.save(filename=os.path.join(filepath, saved_filename))
+                img.close()
+            else:
+                # upload of jpg/png... from hdd
+                img.save(os.path.join(filepath, saved_filename))
+    except (IOError, OSError):
+        log.error(u"Cover-file is not a valid image file, or could not be stored")
+        return False, _(u"Cover-file is not a valid image file, or could not be stored")
    return True, None


@@ -604,31 +635,37 @@ def save_cover_from_filestorage(filepath, saved_filename, img):
 def save_cover(img, book_path):
    content_type = img.headers.get('content-type')

-    if use_PIL:
-        if content_type not in ('image/jpeg', 'image/png', 'image/webp'):
-            log.error("Only jpg/jpeg/png/webp files are supported as coverfile")
-            return False, _("Only jpg/jpeg/png/webp files are supported as coverfile")
+    if use_IM:
+        if content_type not in ('image/jpeg', 'image/png', 'image/webp', 'image/bmp'):
+            log.error("Only jpg/jpeg/png/webp/bmp files are supported as coverfile")
+            return False, _("Only jpg/jpeg/png/webp/bmp files are supported as coverfile")
        # convert to jpg because calibre only supports jpg
-        if content_type in ('image/png', 'image/webp'):
-            if hasattr(img, 'stream'):
-                imgc = PILImage.open(img.stream)
-            else:
-                imgc = PILImage.open(io.BytesIO(img.content))
-            im = imgc.convert('RGB')
-            tmp_bytesio = io.BytesIO()
-            im.save(tmp_bytesio, format='JPEG')
-            img._content = tmp_bytesio.getvalue()
+        if content_type != 'image/jpg':
+            try:
+                if hasattr(img, 'stream'):
+                    imgc = Image(blob=img.stream)
+                else:
+                    imgc = Image(blob=io.BytesIO(img.content))
+                imgc.format = 'jpeg'
+                imgc.transform_colorspace("rgb")
+                img = imgc
+            except (BlobError, MissingDelegateError):
+                log.error("Invalid cover file content")
+                return False, _("Invalid cover file content")
    else:
        if content_type not in 'image/jpeg':
            log.error("Only jpg/jpeg files are supported as coverfile")
            return False, _("Only jpg/jpeg files are supported as coverfile")

    if config.config_use_google_drive:
-        tmpDir = gettempdir()
-        ret, message = save_cover_from_filestorage(tmpDir, "uploaded_cover.jpg", img)
+        tmp_dir = os.path.join(gettempdir(), 'calibre_web')
+
+        if not os.path.isdir(tmp_dir):
+            os.mkdir(tmp_dir)
+        ret, message = save_cover_from_filestorage(tmp_dir, "uploaded_cover.jpg", img)
        if ret is True:
-            gd.uploadFileToEbooksFolder(os.path.join(book_path, 'cover.jpg'),
-                                        os.path.join(tmpDir, "uploaded_cover.jpg"))
+            gd.uploadFileToEbooksFolder(os.path.join(book_path, 'cover.jpg').replace("\\","/"),
+                                        os.path.join(tmp_dir, "uploaded_cover.jpg"))
            log.info("Cover is saved on Google Drive")
            return True, None
        else:
@@ -639,9 +676,9 @@ def save_cover(img, book_path):

 def do_download_file(book, book_format, client, data, headers):
    if config.config_use_google_drive:
-        startTime = time.time()
+        #startTime = time.time()
        df = gd.getFileFromEbooksFolder(book.path, data.name + "." + book_format)
-        log.debug('%s', time.time() - startTime)
+        #log.debug('%s', time.time() - startTime)
        if df:
            return gd.do_gdrive_download(df, headers)
        else:
@@ -659,6 +696,7 @@ def do_download_file(book, book_format, client, data, headers):
        # ToDo Check headers parameter
        for element in headers:
            response.headers[element[0]] = element[1]
+        log.info('Downloading file: {}'.format(os.path.join(filename, data.name + "." + book_format)))
        return response

 ##################################
@@ -672,17 +710,14 @@ def check_unrar(unrarLocation):
        return _('Unrar binary file not found')

    try:
-        if sys.version_info < (3, 0):
-            unrarLocation = unrarLocation.encode(sys.getfilesystemencoding())
        unrarLocation = [unrarLocation]
-        for lines in process_wait(unrarLocation):
-            value = re.search('UNRAR (.*) freeware', lines, re.IGNORECASE)
-            if value:
-                version = value.group(1)
-                log.debug("unrar version %s", version)
-                break
+        value = process_wait(unrarLocation, pattern='UNRAR (.*) freeware')
+        if value:
+            version = value.group(1)
+            log.debug("unrar version %s", version)
+
    except (OSError, UnicodeDecodeError) as err:
-        log.exception(err)
+        log.debug_or_exception(err)
        return _('Error excecuting UnRar')


@@ -698,7 +733,6 @@ def json_serial(obj):
            'seconds': obj.seconds,
            'microseconds': obj.microseconds,
        }
-        # return obj.isoformat()
    raise TypeError("Type %s not serializable" % type(obj))


@@ -722,47 +756,30 @@ def format_runtime(runtime):
 # helper function to apply localize status information in tasklist entries
 def render_task_status(tasklist):
    renderedtasklist = list()
-    for task in tasklist:
-        if task['user'] == current_user.nickname or current_user.role_admin():
-            if task['formStarttime']:
-                task['starttime'] = format_datetime(task['formStarttime'], format='short', locale=get_locale())
-            # task2['formStarttime'] = ""
-            else:
-                if 'starttime' not in task:
-                    task['starttime'] = ""
-
-            if 'formRuntime' not in task:
-                task['runtime'] = ""
-            else:
-                task['runtime'] = format_runtime(task['formRuntime'])
+    for __, user, __, task in tasklist:
+        if user == current_user.name or current_user.role_admin():
+            ret = {}
+            if task.start_time:
+                ret['starttime'] = format_datetime(task.start_time, format='short', locale=get_locale())
+                ret['runtime'] = format_runtime(task.runtime)

            # localize the task status
-            if isinstance(task['stat'], int):
-                if task['stat'] == STAT_WAITING:
-                    task['status'] = _(u'Waiting')
-                elif task['stat'] == STAT_FAIL:
-                    task['status'] = _(u'Failed')
-                elif task['stat'] == STAT_STARTED:
-                    task['status'] = _(u'Started')
-                elif task['stat'] == STAT_FINISH_SUCCESS:
-                    task['status'] = _(u'Finished')
+            if isinstance(task.stat, int):
+                if task.stat == STAT_WAITING:
+                    ret['status'] = _(u'Waiting')
+                elif task.stat == STAT_FAIL:
+                    ret['status'] = _(u'Failed')
+                elif task.stat == STAT_STARTED:
+                    ret['status'] = _(u'Started')
+                elif task.stat == STAT_FINISH_SUCCESS:
+                    ret['status'] = _(u'Finished')
                else:
-                    task['status'] = _(u'Unknown Status')
+                    ret['status'] = _(u'Unknown Status')

-            # localize the task type
-            if isinstance(task['taskType'], int):
-                if task['taskType'] == TASK_EMAIL:
-                    task['taskMessage'] = _(u'E-mail: ') + task['taskMess']
-                elif task['taskType'] == TASK_CONVERT:
-                    task['taskMessage'] = _(u'Convert: ') + task['taskMess']
-                elif task['taskType'] == TASK_UPLOAD:
-                    task['taskMessage'] = _(u'Upload: ') + task['taskMess']
-                elif task['taskType'] == TASK_CONVERT_ANY:
-                    task['taskMessage'] = _(u'Convert: ') + task['taskMess']
-                else:
-                    task['taskMessage'] = _(u'Unknown Task: ') + task['taskMess']
-
-            renderedtasklist.append(task)
+            ret['taskMessage'] = "{}: {}".format(_(task.name), task.message)
+            ret['progress'] = "{} %".format(int(task.progress * 100))
+            ret['user'] = escape(user)  # prevent xss
+            renderedtasklist.append(ret)

    return renderedtasklist

@@ -778,8 +795,8 @@ def tags_filters():
 # checks if domain is in database (including wildcards)
 # example SELECT * FROM @TABLE WHERE  'abcdefg' LIKE Name;
 # from https://code.luasoftware.com/tutorials/flask/execute-raw-sql-in-flask-sqlalchemy/
+# in all calls the email address is checked for validity
 def check_valid_domain(domain_text):
-    # domain_text = domain_text.split('@', 1)[-1].lower()
    sql = "SELECT * FROM registration WHERE (:domain LIKE domain and allow = 1);"
    result = ub.session.query(ub.Registration).from_statement(text(sql)).params(domain=domain_text).all()
    if not len(result):
@@ -809,10 +826,11 @@ def get_cc_columns(filter_config_custom_read=False):

 def get_download_link(book_id, book_format, client):
    book_format = book_format.split(".")[0]
-    book = calibre_db.get_filtered_book(book_id)
+    book = calibre_db.get_filtered_book(book_id, allow_show_archived=True)
    if book:
        data1 = calibre_db.get_book_format(book.id, book_format.upper())
    else:
+        log.error("Book id {} not found for downloading".format(book_id))
        abort(404)
    if data1:
        # collect downloaded books only for registered user and not for anonymous user
@@ -820,8 +838,8 @@ def get_download_link(book_id, book_format, client):
            ub.update_download(book_id, int(current_user.id))
        file_name = book.title
        if len(book.authors) > 0:
-            file_name = book.authors[0].name + '_' + file_name
-        file_name = get_valid_filename(file_name)
+            file_name = file_name + ' - ' + book.authors[0].name
+        file_name = get_valid_filename(file_name, replace_whitespace=False)
        headers = Headers()
        headers["Content-Type"] = mimetypes.types_map.get('.' + book_format, "application/octet-stream")
        headers["Content-Disposition"] = "attachment; filename=%s.%s; filename*=UTF-8''%s.%s" % (
@@ -16,9 +16,10 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
-
 from .iso_language_names import LANGUAGE_NAMES as _LANGUAGE_NAMES
+from . import logger
+
+log = logger.create()


 try:
@@ -52,32 +53,39 @@ def get_language_names(locale):


 def get_language_name(locale, lang_code):
-    return get_language_names(locale)[lang_code]
+    try:
+        return get_language_names(locale)[lang_code]
+    except KeyError:
+        log.error('Missing translation for language name: {}'.format(lang_code))
+        return "Unknown"


 def get_language_codes(locale, language_names, remainder=None):
    language_names = set(x.strip().lower() for x in language_names if x)
-    languages = list()
+    lang = list()
    for k, v in get_language_names(locale).items():
        v = v.lower()
        if v in language_names:
-            languages.append(k)
+            lang.append(k)
            language_names.remove(v)
-    if remainder is not None:
+    if remainder is not None and language_names:
        remainder.extend(language_names)
-    return languages
+    return lang
+
+

 def get_valid_language_codes(locale, language_names, remainder=None):
-    languages = list()
+    lang = list()
    if "" in language_names:
        language_names.remove("")
-    for k, v in get_language_names(locale).items():
+    for k, __ in get_language_names(locale).items():
        if k in language_names:
-            languages.append(k)
+            lang.append(k)
            language_names.remove(k)
    if remainder is not None and len(language_names):
        remainder.extend(language_names)
-    return languages
+    return lang
+

 def get_lang3(lang):
    try:
@@ -22,16 +22,15 @@

 # custom jinja filters

-from __future__ import division, print_function, unicode_literals
 import datetime
 import mimetypes
-import re
+from uuid import uuid4

 from babel.dates import format_date
 from flask import Blueprint, request, url_for
 from flask_babel import get_locale
 from flask_login import current_user
-
+from markupsafe import escape
 from . import logger


@@ -44,6 +43,8 @@ log = logger.create()
 def url_for_other_page(page):
    args = request.view_args.copy()
    args['page'] = page
+    for get, val in request.args.items():
+        args[get] = val
    return url_for(request.endpoint, **args)


@@ -76,22 +77,18 @@ def mimetype_filter(val):
@jinjia.app_template_filter('formatdate')
 def formatdate_filter(val):
    try:
-        conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', val)
-        formatdate = datetime.datetime.strptime(conformed_timestamp[:15], "%Y%m%d %H%M%S")
-        return format_date(formatdate, format='medium', locale=get_locale())
+        return format_date(val, format='medium', locale=get_locale())
    except AttributeError as e:
        log.error('Babel error: %s, Current user locale: %s, Current User: %s', e,
                  current_user.locale,
-                  current_user.nickname
+                  current_user.name
                  )
-        return formatdate
+        return val


@jinjia.app_template_filter('formatdateinput')
 def format_date_input(val):
-    conformed_timestamp = re.sub(r"[:]|([-](?!((\d{2}[:]\d{2})|(\d{4}))$))", '', val)
-    date_obj = datetime.datetime.strptime(conformed_timestamp[:15], "%Y%m%d %H%M%S")
-    input_date = date_obj.isoformat().split('T', 1)[0]  # Hack to support dates <1900
+    input_date = val.isoformat().split('T', 1)[0]  # Hack to support dates <1900
    return '' if input_date == "0101-01-01" else input_date


@@ -112,9 +109,31 @@ def timestamptodate(date, fmt=None):
 def yesno(value, yes, no):
    return yes if value else no

+
@jinjia.app_template_filter('formatfloat')
 def formatfloat(value, decimals=1):
-    formatedstring = '%d' % value
-    if (value % 1) != 0:
-        formatedstring = ('%s.%d' % (formatedstring, (value % 1) * 10**decimals)).rstrip('0')
-    return formatedstring
+    value = 0 if not value else value
+    return ('{0:.' + str(decimals) + 'f}').format(value).rstrip('0').rstrip('.')
+
+
+@jinjia.app_template_filter('formatseriesindex')
+def formatseriesindex_filter(series_index):
+    if series_index:
+        try:
+            if int(series_index) - series_index == 0:
+                return int(series_index)
+            else:
+                return series_index
+        except ValueError:
+            return series_index
+    return 0
+
+@jinjia.app_template_filter('escapedlink')
+def escapedlink_filter(url, text):
+    return "<a href='{}'>{}</a>".format(url, escape(text))
+
+@jinjia.app_template_filter('uuidfilter')
+def uuidfilter(var):
+    return uuid4()
+
+
@@ -19,15 +19,11 @@

 import base64
 import datetime
-import sys
 import os
 import uuid
 from time import gmtime, strftime
-
-try:
-    from urllib import unquote
-except ImportError:
-    from urllib.parse import unquote
+import json
+from urllib.parse import unquote

 from flask import (
    Blueprint,
@@ -39,22 +35,28 @@ from flask import (
    redirect,
    abort
 )
-from flask_login import current_user, login_required
+from flask_login import current_user
 from werkzeug.datastructures import Headers
 from sqlalchemy import func
 from sqlalchemy.sql.expression import and_, or_
 from sqlalchemy.exc import StatementError
+from sqlalchemy.sql import select
 import requests

-from . import config, logger, kobo_auth, db, calibre_db, helper, shelf as shelf_lib, ub
+
+from . import config, logger, kobo_auth, db, calibre_db, helper, shelf as shelf_lib, ub, csrf, kobo_sync_status
+from .constants import sqlalchemy_version2
+from .helper import get_download_link
 from .services import SyncToken as SyncToken
 from .web import download_required
-from .kobo_auth import requires_kobo_auth
+from .kobo_auth import requires_kobo_auth, get_auth_token

 KOBO_FORMATS = {"KEPUB": ["KEPUB"], "EPUB": ["EPUB3", "EPUB"]}
 KOBO_STOREAPI_URL = "https://storeapi.kobo.com"
 KOBO_IMAGEHOST_URL = "https://kbimages1-a.akamaihd.net"

+SYNC_ITEM_LIMIT = 100
+
 kobo = Blueprint("kobo", __name__, url_prefix="/kobo/<auth_token>")
 kobo_auth.disable_failed_auth_redirect_for_blueprint(kobo)
 kobo_auth.register_url_value_preprocessor(kobo)
@@ -78,6 +80,7 @@ CONNECTION_SPECIFIC_HEADERS = [
    "transfer-encoding",
 ]

+
 def get_kobo_activated():
    return config.config_kobo_sync

@@ -96,6 +99,8 @@ def make_request_to_kobo_store(sync_token=None):
        allow_redirects=False,
        timeout=(2, 10)
    )
+    log.debug("Content: " + str(store_response.content))
+    log.debug("StatusCode: " + str(store_response.status_code))
    return store_response


@@ -104,7 +109,8 @@ def redirect_or_proxy_request():
        if request.method == "GET":
            return redirect(get_store_url_for_current_request(), 307)
        else:
-            # The Kobo device turns other request types into GET requests on redirects, so we instead proxy to the Kobo store ourselves.
+            # The Kobo device turns other request types into GET requests on redirects,
+            # so we instead proxy to the Kobo store ourselves.
            store_response = make_request_to_kobo_store()

            response_headers = store_response.headers
@@ -119,7 +125,11 @@ def redirect_or_proxy_request():


 def convert_to_kobo_timestamp_string(timestamp):
-    return timestamp.strftime("%Y-%m-%dT%H:%M:%SZ")
+    try:
+        return timestamp.strftime("%Y-%m-%dT%H:%M:%SZ")
+    except AttributeError as exc:
+        log.debug("Timestamp not valid: {}".format(exc))
+        return datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")


@kobo.route("/v1/library/sync")
@@ -128,83 +138,169 @@ def convert_to_kobo_timestamp_string(timestamp):
 def HandleSyncRequest():
    sync_token = SyncToken.SyncToken.from_headers(request.headers)
    log.info("Kobo library sync request received.")
+    log.debug("SyncToken: {}".format(sync_token))
    if not current_app.wsgi_app.is_proxied:
        log.debug('Kobo: Received unproxied request, changed request port to external server port')

-    # TODO: Limit the number of books return per sync call, and rely on the sync-continuatation header
-    # instead so that the device triggers another sync.
+    # if no books synced don't respect sync_token
+    if not ub.session.query(ub.KoboSyncedBooks).filter(ub.KoboSyncedBooks.user_id == current_user.id).count():
+        sync_token.books_last_modified = datetime.datetime.min
+        sync_token.books_last_created = datetime.datetime.min
+        sync_token.reading_state_last_modified = datetime.datetime.min

-    new_books_last_modified = sync_token.books_last_modified
-    new_books_last_created = sync_token.books_last_created
+    new_books_last_modified = sync_token.books_last_modified # needed for sync selected shelfs only
+    new_books_last_created = sync_token.books_last_created # needed to distinguish between new and changed entitlement
    new_reading_state_last_modified = sync_token.reading_state_last_modified
+
+    new_archived_last_modified = datetime.datetime.min
    sync_results = []

    # We reload the book database so that the user get's a fresh view of the library
    # in case of external changes (e.g: adding a book through Calibre).
    calibre_db.reconnect_db(config, ub.app_DB_path)

-    archived_books = (
-        ub.session.query(ub.ArchivedBook)
-        .filter(ub.ArchivedBook.user_id == int(current_user.id))
-        .all()
-    )
+    only_kobo_shelves = current_user.kobo_only_shelves_sync

-    # We join-in books that have had their Archived bit recently modified in order to either:
-    #   * Restore them to the user's device.
-    #   * Delete them from the user's device.
-    # (Ideally we would use a join for this logic, however cross-database joins don't look trivial in SqlAlchemy.)
-    recently_restored_or_archived_books = []
-    archived_book_ids = {}
-    new_archived_last_modified = datetime.datetime.min
-    for archived_book in archived_books:
-        if archived_book.last_modified > sync_token.archive_last_modified:
-            recently_restored_or_archived_books.append(archived_book.book_id)
-        if archived_book.is_archived:
-            archived_book_ids[archived_book.book_id] = True
-        new_archived_last_modified = max(
-            new_archived_last_modified, archived_book.last_modified)
+    if only_kobo_shelves:
+        if sqlalchemy_version2:
+            changed_entries = select(db.Books,
+                                     ub.ArchivedBook.last_modified,
+                                     ub.BookShelf.date_added,
+                                     ub.ArchivedBook.is_archived)
+        else:
+            changed_entries = calibre_db.session.query(db.Books,
+                                                       ub.ArchivedBook.last_modified,
+                                                       ub.BookShelf.date_added,
+                                                       ub.ArchivedBook.is_archived)
+        changed_entries = (changed_entries
+                           .join(db.Data).outerjoin(ub.ArchivedBook, and_(db.Books.id == ub.ArchivedBook.book_id,
+                                                                          ub.ArchivedBook.user_id == current_user.id))
+                           .filter(db.Books.id.notin_(calibre_db.session.query(ub.KoboSyncedBooks.book_id)
+                                           .filter(ub.KoboSyncedBooks.user_id == current_user.id)))
+                .filter(ub.BookShelf.date_added > sync_token.books_last_modified)
+                .filter(db.Data.format.in_(KOBO_FORMATS))
+                .filter(calibre_db.common_filters(allow_show_archived=True))
+                .order_by(db.Books.id)
+                .order_by(ub.ArchivedBook.last_modified)
+                .join(ub.BookShelf, db.Books.id == ub.BookShelf.book_id)
+                .join(ub.Shelf)
+                .filter(ub.Shelf.user_id == current_user.id)
+                .filter(ub.Shelf.kobo_sync)
+                .distinct()
+        )
+    else:
+        if sqlalchemy_version2:
+            changed_entries = select(db.Books, ub.ArchivedBook.last_modified, ub.ArchivedBook.is_archived)
+        else:
+            changed_entries = calibre_db.session.query(db.Books,
+                                                       ub.ArchivedBook.last_modified,
+                                                       ub.ArchivedBook.is_archived)
+        changed_entries = (changed_entries
+                   .join(db.Data).outerjoin(ub.ArchivedBook, and_(db.Books.id == ub.ArchivedBook.book_id,
+                                                                  ub.ArchivedBook.user_id == current_user.id))
+                   .filter(db.Books.id.notin_(calibre_db.session.query(ub.KoboSyncedBooks.book_id)
+                                              .filter(ub.KoboSyncedBooks.user_id == current_user.id)))
+                   .filter(calibre_db.common_filters(allow_show_archived=True))
+                   .filter(db.Data.format.in_(KOBO_FORMATS))
+                   .order_by(db.Books.last_modified)
+                   .order_by(db.Books.id)
+        )

-    # sqlite gives unexpected results when performing the last_modified comparison without the datetime cast.
-    # It looks like it's treating the db.Books.last_modified field as a string and may fail
-    # the comparison because of the +00:00 suffix.
-    changed_entries = (
-        calibre_db.session.query(db.Books)
-        .join(db.Data)
-        .filter(or_(func.datetime(db.Books.last_modified) > sync_token.books_last_modified,
-                    db.Books.id.in_(recently_restored_or_archived_books)))
-        .filter(db.Data.format.in_(KOBO_FORMATS))
-        .all()
-    )

    reading_states_in_new_entitlements = []
-    for book in changed_entries:
-        kobo_reading_state = get_or_create_reading_state(book.id)
+    if sqlalchemy_version2:
+        books = calibre_db.session.execute(changed_entries.limit(SYNC_ITEM_LIMIT))
+    else:
+        books = changed_entries.limit(SYNC_ITEM_LIMIT)
+    log.debug("Books to Sync: {}".format(len(books.all())))
+    for book in books:
+        formats = [data.format for data in book.Books.data]
+        if not 'KEPUB' in formats and config.config_kepubifypath and 'EPUB' in formats:
+            helper.convert_book_format(book.Books.id, config.config_calibre_dir, 'EPUB', 'KEPUB', current_user.name)
+
+        kobo_reading_state = get_or_create_reading_state(book.Books.id)
        entitlement = {
-            "BookEntitlement": create_book_entitlement(book, archived=(book.id in archived_book_ids)),
-            "BookMetadata": get_metadata(book),
+            "BookEntitlement": create_book_entitlement(book.Books, archived=(book.is_archived == True)),
+            "BookMetadata": get_metadata(book.Books),
        }

        if kobo_reading_state.last_modified > sync_token.reading_state_last_modified:
-            entitlement["ReadingState"] = get_kobo_reading_state_response(book, kobo_reading_state)
+            entitlement["ReadingState"] = get_kobo_reading_state_response(book.Books, kobo_reading_state)
            new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified)
-            reading_states_in_new_entitlements.append(book.id)
+            reading_states_in_new_entitlements.append(book.Books.id)

-        if book.timestamp > sync_token.books_last_created:
+        ts_created = book.Books.timestamp
+
+        try:
+            ts_created = max(ts_created, book.date_added)
+        except AttributeError:
+            pass
+
+        if ts_created > sync_token.books_last_created:
            sync_results.append({"NewEntitlement": entitlement})
        else:
            sync_results.append({"ChangedEntitlement": entitlement})

        new_books_last_modified = max(
-            book.last_modified, new_books_last_modified
+            book.Books.last_modified, new_books_last_modified
        )
-        new_books_last_created = max(book.timestamp, new_books_last_created)
+        try:
+            new_books_last_modified = max(
+                new_books_last_modified, book.date_added
+            )
+        except AttributeError:
+            pass

-    changed_reading_states = (
-        ub.session.query(ub.KoboReadingState)
-        .filter(and_(func.datetime(ub.KoboReadingState.last_modified) > sync_token.reading_state_last_modified,
-                     ub.KoboReadingState.user_id == current_user.id,
-                     ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements))))
-    for kobo_reading_state in changed_reading_states.all():
+        new_books_last_created = max(ts_created, new_books_last_created)
+        kobo_sync_status.add_synced_books(book.Books.id)
+
+    if sqlalchemy_version2:
+        max_change = calibre_db.session.execute(changed_entries
+                                                .filter(ub.ArchivedBook.is_archived)
+                                                .filter(ub.ArchivedBook.user_id == current_user.id)
+                                                .order_by(func.datetime(ub.ArchivedBook.last_modified).desc()))\
+            .columns(db.Books).first()
+    else:
+        max_change = changed_entries.from_self().filter(ub.ArchivedBook.is_archived)\
+            .filter(ub.ArchivedBook.user_id==current_user.id) \
+            .order_by(func.datetime(ub.ArchivedBook.last_modified).desc()).first()
+
+    max_change = max_change.last_modified if max_change else new_archived_last_modified
+
+    new_archived_last_modified = max(new_archived_last_modified, max_change)
+
+    # no. of books returned
+    if sqlalchemy_version2:
+        entries = calibre_db.session.execute(changed_entries).all()
+        book_count = len(entries)
+    else:
+        book_count = changed_entries.count()
+    # last entry:
+    cont_sync = bool(book_count)
+    log.debug("Remaining books to Sync: {}".format(book_count))
+    # generate reading state data
+    changed_reading_states = ub.session.query(ub.KoboReadingState)
+
+    if only_kobo_shelves:
+        changed_reading_states = changed_reading_states.join(ub.BookShelf,
+                                                             ub.KoboReadingState.book_id == ub.BookShelf.book_id)\
+            .join(ub.Shelf)\
+            .filter(current_user.id == ub.Shelf.user_id)\
+            .filter(ub.Shelf.kobo_sync,
+                    or_(
+                        ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified,
+                        func.datetime(ub.BookShelf.date_added) > sync_token.books_last_modified
+                    )).distinct()
+    else:
+        changed_reading_states = changed_reading_states.filter(
+            ub.KoboReadingState.last_modified > sync_token.reading_state_last_modified)
+
+    changed_reading_states = changed_reading_states.filter(
+        and_(ub.KoboReadingState.user_id == current_user.id,
+             ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements)))\
+        .order_by(ub.KoboReadingState.last_modified)
+    cont_sync |= bool(changed_reading_states.count() > SYNC_ITEM_LIMIT)
+    for kobo_reading_state in changed_reading_states.limit(SYNC_ITEM_LIMIT).all():
        book = calibre_db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none()
        if book:
            sync_results.append({
@@ -214,19 +310,21 @@ def HandleSyncRequest():
            })
            new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified)

-    sync_shelves(sync_token, sync_results)
+    sync_shelves(sync_token, sync_results, only_kobo_shelves)

-    sync_token.books_last_created = new_books_last_created
+    # update last created timestamp to distinguish between new and changed entitlements
+    if not cont_sync:
+        sync_token.books_last_created = new_books_last_created
    sync_token.books_last_modified = new_books_last_modified
    sync_token.archive_last_modified = new_archived_last_modified
    sync_token.reading_state_last_modified = new_reading_state_last_modified

-    return generate_sync_response(sync_token, sync_results)
+    return generate_sync_response(sync_token, sync_results, cont_sync)


-def generate_sync_response(sync_token, sync_results):
+def generate_sync_response(sync_token, sync_results, set_cont=False):
    extra_headers = {}
-    if config.config_kobo_proxy:
+    if config.config_kobo_proxy and not set_cont:
        # Merge in sync results from the official Kobo store.
        try:
            store_response = make_request_to_kobo_store(sync_token)
@@ -238,12 +336,16 @@ def generate_sync_response(sync_token, sync_results):
            extra_headers["x-kobo-sync-mode"] = store_response.headers.get("x-kobo-sync-mode")
            extra_headers["x-kobo-recent-reads"] = store_response.headers.get("x-kobo-recent-reads")

-        except Exception as e:
-            log.error("Failed to receive or parse response from Kobo's sync endpoint: " + str(e))
+        except Exception as ex:
+            log.error("Failed to receive or parse response from Kobo's sync endpoint: {}".format(ex))
+    if set_cont:
+        extra_headers["x-kobo-sync"] = "continue"
    sync_token.to_headers(extra_headers)

-    response = make_response(jsonify(sync_results), extra_headers)
-
+    # log.debug("Kobo Sync Content: {}".format(sync_results))
+    # jsonify decodes the unicode string different to what kobo expects
+    response = make_response(json.dumps(sync_results), extra_headers)
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
    return response


@@ -260,7 +362,9 @@ def HandleMetadataRequest(book_uuid):
        return redirect_or_proxy_request()

    metadata = get_metadata(book)
-    return jsonify([metadata])
+    response = make_response(json.dumps([metadata], ensure_ascii=False))
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+    return response


 def get_download_url_for_book(book, book_format):
@@ -270,15 +374,17 @@ def get_download_url_for_book(book, book_format):
        else:
            host = request.host

-        return "{url_scheme}://{url_base}:{url_port}/download/{book_id}/{book_format}".format(
+        return "{url_scheme}://{url_base}:{url_port}/kobo/{auth_token}/download/{book_id}/{book_format}".format(
            url_scheme=request.scheme,
            url_base=host,
            url_port=config.config_external_port,
+            auth_token=get_auth_token(),
            book_id=book.id,
            book_format=book_format.lower()
        )
    return url_for(
-        "web.download_link",
+        "kobo.download_book",
+        auth_token=kobo_auth.get_auth_token(),
        book_id=book.id,
        book_format=book_format.lower(),
        _external=True,
@@ -286,7 +392,7 @@ def get_download_url_for_book(book, book_format):


 def create_book_entitlement(book, archived):
-    book_uuid = book.uuid
+    book_uuid = str(book.uuid)
    return {
        "Accessibility": "Full",
        "ActivePeriod": {"From": convert_to_kobo_timestamp_string(datetime.datetime.now())},
@@ -313,18 +419,15 @@ def get_description(book):
    return book.comments[0].text


-# TODO handle multiple authors
 def get_author(book):
    if not book.authors:
        return {"Contributors": None}
-    if len(book.authors) > 1:
-        author_list = []
-        autor_roles = []
-        for author in book.authors:
-            autor_roles.append({"Name":author.name, "Role":"Author"})
-            author_list.append(author.name)
-        return {"ContributorRoles": autor_roles, "Contributors":author_list}
-    return {"ContributorRoles": [{"Name":book.authors[0].name, "Role":"Author"}], "Contributors": book.authors[0].name}
+    author_list = []
+    autor_roles = []
+    for author in book.authors:
+        autor_roles.append({"Name":author.name})    #.encode('unicode-escape').decode('latin-1')
+        author_list.append(author.name)
+    return {"ContributorRoles": autor_roles, "Contributors":author_list}


 def get_publisher(book):
@@ -344,7 +447,9 @@ def get_seriesindex(book):

 def get_metadata(book):
    download_urls = []
-    for book_data in book.data:
+    kepub = [data for data in book.data if data.format == 'KEPUB']
+
+    for book_data in kepub if len(kepub) > 0 else book.data:
        if book_data.format not in KOBO_FORMATS:
            continue
        for kobo_format in KOBO_FORMATS[book_data.format]:
@@ -362,7 +467,7 @@ def get_metadata(book):

    book_uuid = book.uuid
    metadata = {
-        "Categories": ["00000000-0000-0000-0000-000000000001",],
+        "Categories": ["00000000-0000-0000-0000-000000000001", ],
        # "Contributors": get_author(book),
        "CoverImageId": book_uuid,
        "CrossRevisionId": book_uuid,
@@ -379,9 +484,7 @@ def get_metadata(book):
        "IsSocialEnabled": True,
        "Language": "en",
        "PhoneticPronunciations": {},
-        # TODO: Fix book.pubdate to return a datetime object so that we can easily
-        # convert it to the format Kobo devices expect.
-        "PublicationDate": book.pubdate,
+        "PublicationDate": convert_to_kobo_timestamp_string(book.pubdate),
        "Publisher": {"Imprint": "", "Name": get_publisher(book),},
        "RevisionId": book_uuid,
        "Title": book.title,
@@ -390,21 +493,18 @@ def get_metadata(book):
    metadata.update(get_author(book))

    if get_series(book):
-        if sys.version_info < (3, 0):
-            name = get_series(book).encode("utf-8")
-        else:
-            name = get_series(book)
+        name = get_series(book)
        metadata["Series"] = {
            "Name": get_series(book),
            "Number": get_seriesindex(book),        # ToDo Check int() ?
            "NumberFloat": float(get_seriesindex(book)),
            # Get a deterministic id based on the series name.
-            "Id": uuid.uuid3(uuid.NAMESPACE_DNS, name),
+            "Id": str(uuid.uuid3(uuid.NAMESPACE_DNS, name)),
        }

    return metadata

-
+@csrf.exempt
@kobo.route("/v1/library/tags", methods=["POST", "DELETE"])
@requires_kobo_auth
 # Creates a Shelf with the given items, and returns the shelf's uuid.
@@ -435,11 +535,11 @@ def HandleTagCreate():
    items_unknown_to_calibre = add_items_to_shelf(items, shelf)
    if items_unknown_to_calibre:
        log.debug("Received request to add unknown books to a collection. Silently ignoring items.")
-    ub.session.commit()
-
+    ub.session_commit()
    return make_response(jsonify(str(shelf.uuid)), 201)


+@csrf.exempt
@kobo.route("/v1/library/tags/<tag_id>", methods=["DELETE", "PUT"])
@requires_kobo_auth
 def HandleTagUpdate(tag_id):
@@ -468,7 +568,7 @@ def HandleTagUpdate(tag_id):

        shelf.name = name
        ub.session.merge(shelf)
-        ub.session.commit()
+        ub.session_commit()
    return make_response(' ', 200)


@@ -495,6 +595,7 @@ def add_items_to_shelf(items, shelf):
    return items_unknown_to_calibre


+@csrf.exempt
@kobo.route("/v1/library/tags/<tag_id>/items", methods=["POST"])
@requires_kobo_auth
 def HandleTagAddItem(tag_id):
@@ -520,11 +621,11 @@ def HandleTagAddItem(tag_id):
        log.debug("Received request to add an unknown book to a collection. Silently ignoring item.")

    ub.session.merge(shelf)
-    ub.session.commit()
-
+    ub.session_commit()
    return make_response('', 201)


+@csrf.exempt
@kobo.route("/v1/library/tags/<tag_id>/items/delete", methods=["POST"])
@requires_kobo_auth
 def HandleTagRemoveItem(tag_id):
@@ -561,7 +662,7 @@ def HandleTagRemoveItem(tag_id):
            shelf.books.filter(ub.BookShelf.book_id == book.id).delete()
        except KeyError:
            items_unknown_to_calibre.append(item)
-    ub.session.commit()
+    ub.session_commit()

    if items_unknown_to_calibre:
        log.debug("Received request to remove an unknown book to a collecition. Silently ignoring item.")
@@ -571,13 +672,11 @@ def HandleTagRemoveItem(tag_id):

 # Add new, changed, or deleted shelves to the sync_results.
 # Note: Public shelves that aren't owned by the user aren't supported.
-def sync_shelves(sync_token, sync_results):
+def sync_shelves(sync_token, sync_results, only_kobo_shelves=False):
    new_tags_last_modified = sync_token.tags_last_modified
-
-    for shelf in ub.session.query(ub.ShelfArchive).filter(func.datetime(ub.ShelfArchive.last_modified) > sync_token.tags_last_modified,
-                                                          ub.ShelfArchive.user_id == current_user.id):
+    # transmit all archived shelfs independent of last sync (why should this matter?)
+    for shelf in ub.session.query(ub.ShelfArchive).filter(ub.ShelfArchive.user_id == current_user.id):
        new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified)
-
        sync_results.append({
            "DeletedTag": {
                "Tag": {
@@ -586,9 +685,43 @@ def sync_shelves(sync_token, sync_results):
                }
            }
        })
+        ub.session.delete(shelf)
+        ub.session_commit()

-    for shelf in ub.session.query(ub.Shelf).filter(func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified,
-                                                   ub.Shelf.user_id == current_user.id):
+    extra_filters = []
+    if only_kobo_shelves:
+        for shelf in ub.session.query(ub.Shelf).filter(
+            func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified,
+            ub.Shelf.user_id == current_user.id,
+            not ub.Shelf.kobo_sync
+        ):
+            sync_results.append({
+                "DeletedTag": {
+                    "Tag": {
+                        "Id": shelf.uuid,
+                        "LastModified": convert_to_kobo_timestamp_string(shelf.last_modified)
+                    }
+                }
+            })
+        extra_filters.append(ub.Shelf.kobo_sync)
+
+    if sqlalchemy_version2:
+        shelflist = ub.session.execute(select(ub.Shelf).outerjoin(ub.BookShelf).filter(
+            or_(func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified,
+                func.datetime(ub.BookShelf.date_added) > sync_token.tags_last_modified),
+            ub.Shelf.user_id == current_user.id,
+            *extra_filters
+        ).distinct().order_by(func.datetime(ub.Shelf.last_modified).asc())).columns(ub.Shelf)
+    else:
+        shelflist = ub.session.query(ub.Shelf).outerjoin(ub.BookShelf).filter(
+            or_(func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified,
+                func.datetime(ub.BookShelf.date_added) > sync_token.tags_last_modified),
+            ub.Shelf.user_id == current_user.id,
+            *extra_filters
+        ).distinct().order_by(func.datetime(ub.Shelf.last_modified).asc())
+
+
+    for shelf in shelflist:
        if not shelf_lib.check_shelf_view_permissions(shelf):
            continue

@@ -607,7 +740,7 @@ def sync_shelves(sync_token, sync_results):
                "ChangedTag": tag
            })
    sync_token.tags_last_modified = new_tags_last_modified
-    ub.session.commit()
+    ub.session_commit()


 # Creates a Kobo "Tag" object from a ub.Shelf object
@@ -633,7 +766,7 @@ def create_kobo_tag(shelf):
        )
    return {"Tag": tag}

-
+@csrf.exempt
@kobo.route("/v1/library/<book_uuid>/state", methods=["GET", "PUT"])
@requires_kobo_auth
 def HandleStateRequest(book_uuid):
@@ -688,7 +821,7 @@ def HandleStateRequest(book_uuid):
            abort(400, description="Malformed request data is missing 'ReadingStates' key")

        ub.session.merge(kobo_reading_state)
-        ub.session.commit()
+        ub.session_commit()
        return jsonify({
            "RequestResult": "Success",
            "UpdateResults": [update_results_response],
@@ -717,7 +850,7 @@ def get_ub_read_status(kobo_read_status):

 def get_or_create_reading_state(book_id):
    book_read = ub.session.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id,
-                                                          ub.ReadBook.user_id == current_user.id).one_or_none()
+                                                          ub.ReadBook.user_id == int(current_user.id)).one_or_none()
    if not book_read:
        book_read = ub.ReadBook(user_id=current_user.id, book_id=book_id)
    if not book_read.kobo_reading_state:
@@ -726,7 +859,7 @@ def get_or_create_reading_state(book_id):
        kobo_reading_state.statistics = ub.KoboStatistics()
        book_read.kobo_reading_state = kobo_reading_state
    ub.session.add(book_read)
-    ub.session.commit()
+    ub.session_commit()
    return book_read.kobo_reading_state


@@ -808,6 +941,7 @@ def TopLevelEndpoint():
    return make_response(jsonify({}))


+@csrf.exempt
@kobo.route("/v1/library/<book_uuid>", methods=["DELETE"])
@requires_kobo_auth
 def HandleBookDeletionRequest(book_uuid):
@@ -829,12 +963,14 @@ def HandleBookDeletionRequest(book_uuid):
    archived_book.last_modified = datetime.datetime.utcnow()

    ub.session.merge(archived_book)
-    ub.session.commit()
-
-    return ("", 204)
+    ub.session_commit()
+    if archived_book.is_archived:
+        kobo_sync_status.remove_synced_book(book_id)
+    return "", 204


 # TODO: Implement the following routes
+@csrf.exempt
@kobo.route("/v1/library/<dummy>", methods=["DELETE", "GET"])
 def HandleUnimplementedRequest(dummy=None):
    log.debug("Unimplemented Library Request received: %s", request.base_url)
@@ -842,6 +978,7 @@ def HandleUnimplementedRequest(dummy=None):


 # TODO: Implement the following routes
+@csrf.exempt
@kobo.route("/v1/user/loyalty/<dummy>", methods=["GET", "POST"])
@kobo.route("/v1/user/profile", methods=["GET", "POST"])
@kobo.route("/v1/user/wishlist", methods=["GET", "POST"])
@@ -852,30 +989,46 @@ def HandleUserRequest(dummy=None):
    return redirect_or_proxy_request()


+@csrf.exempt
+@kobo.route("/v1/user/loyalty/benefits", methods=["GET"])
+def handle_benefits():
+    if config.config_kobo_proxy:
+        return redirect_or_proxy_request()
+    else:
+        return make_response(jsonify({"Benefits": {}}))
+
+
+@csrf.exempt
+@kobo.route("/v1/analytics/gettests", methods=["GET", "POST"])
+def handle_getests():
+    if config.config_kobo_proxy:
+        return redirect_or_proxy_request()
+    else:
+        testkey = request.headers.get("X-Kobo-userkey","")
+        return make_response(jsonify({"Result": "Success", "TestKey":testkey, "Tests": {}}))
+
+
+@csrf.exempt
@kobo.route("/v1/products/<dummy>/prices", methods=["GET", "POST"])
@kobo.route("/v1/products/<dummy>/recommendations", methods=["GET", "POST"])
@kobo.route("/v1/products/<dummy>/nextread", methods=["GET", "POST"])
@kobo.route("/v1/products/<dummy>/reviews", methods=["GET", "POST"])
+@kobo.route("/v1/products/featured/<dummy>", methods=["GET", "POST"])
+@kobo.route("/v1/products/featured/", methods=["GET", "POST"])
+@kobo.route("/v1/products/books/external/<dummy>", methods=["GET", "POST"])
@kobo.route("/v1/products/books/series/<dummy>", methods=["GET", "POST"])
@kobo.route("/v1/products/books/<dummy>", methods=["GET", "POST"])
+@kobo.route("/v1/products/books/<dummy>/", methods=["GET", "POST"])
@kobo.route("/v1/products/dailydeal", methods=["GET", "POST"])
+@kobo.route("/v1/products/deals", methods=["GET", "POST"])
@kobo.route("/v1/products", methods=["GET", "POST"])
+@kobo.route("/v1/affiliate", methods=["GET", "POST"])
+@kobo.route("/v1/deals", methods=["GET", "POST"])
 def HandleProductsRequest(dummy=None):
    log.debug("Unimplemented Products Request received: %s", request.base_url)
    return redirect_or_proxy_request()


-'''@kobo.errorhandler(404)
-def handle_404(err):
-    # This handler acts as a catch-all for endpoints that we don't have an interest in
-    # implementing (e.g: v1/analytics/gettests, v1/user/recommendations, etc)
-    if err:
-        print('404')
-        return jsonify(error=str(err)), 404
-    log.debug("Unknown Request received: %s, method: %s, data: %s", request.base_url, request.method, request.data)
-    return redirect_or_proxy_request()'''
-
-
 def make_calibre_web_auth_response():
    # As described in kobo_auth.py, CalibreWeb doesn't make use practical use of this auth/device API call for
    # authentation (nor for authorization). We return a dummy response just to keep the device happy.
@@ -895,6 +1048,7 @@ def make_calibre_web_auth_response():
    )


+@csrf.exempt
@kobo.route("/v1/auth/device", methods=["POST"])
@requires_kobo_auth
 def HandleAuthRequest():
@@ -902,7 +1056,7 @@ def HandleAuthRequest():
    if config.config_kobo_proxy:
        try:
            return redirect_or_proxy_request()
-        except:
+        except Exception:
            log.error("Failed to receive or parse response from Kobo's auth endpoint. Falling back to un-proxied mode.")
    return make_calibre_web_auth_response()

@@ -919,7 +1073,7 @@ def HandleInitRequest():
            store_response_json = store_response.json()
            if "Resources" in store_response_json:
                kobo_resources = store_response_json["Resources"]
-        except:
+        except Exception:
            log.error("Failed to receive or parse response from Kobo's init endpoint. Falling back to un-proxied mode.")
    if not kobo_resources:
        kobo_resources = NATIVE_KOBO_RESOURCES()
@@ -976,6 +1130,13 @@ def HandleInitRequest():
    return response


+@kobo.route("/download/<book_id>/<book_format>")
+@requires_kobo_auth
+@download_required
+def download_book(book_id, book_format):
+    return get_download_link(book_id, book_format, "kobo")
+
+
 def NATIVE_KOBO_RESOURCES():
    return {
        "account_page": "https://secure.kobobooks.com/profile",
@@ -62,18 +62,14 @@ particular calls to non-Kobo specific endpoints such as the CalibreWeb book down
 from binascii import hexlify
 from datetime import datetime
 from os import urandom
+from functools import wraps

 from flask import g, Blueprint, url_for, abort, request
-from flask_login import login_user, login_required
+from flask_login import login_user, current_user, login_required
 from flask_babel import gettext as _

-from . import logger, ub, lm
-from .web import render_title_template
-
-try:
-    from functools import wraps
-except ImportError:
-    pass  # We're not using Python 3
+from . import logger, config, calibre_db, db, helper, ub, lm
+from .render_template import render_title_template


 log = logger.create()
@@ -81,6 +77,7 @@ log = logger.create()

 def register_url_value_preprocessor(kobo):
    @kobo.url_value_preprocessor
+    # pylint: disable=unused-variable
    def pop_auth_token(__, values):
        g.auth_token = values.pop("auth_token")

@@ -121,48 +118,50 @@ kobo_auth = Blueprint("kobo_auth", __name__, url_prefix="/kobo_auth")
@kobo_auth.route("/generate_auth_token/<int:user_id>")
@login_required
 def generate_auth_token(user_id):
+    warning = False
    host_list = request.host.rsplit(':')
    if len(host_list) == 1:
        host = ':'.join(host_list)
    else:
        host = ':'.join(host_list[0:-1])
-    if host.startswith('127.') or host.lower() == 'localhost' or host.startswith('[::ffff:7f'):
-        warning = _('PLease access calibre-web from non localhost to get valid api_endpoint for kobo device')
-        return render_title_template(
-            "generate_kobo_auth_url.html",
-            title=_(u"Kobo Setup"),
-            warning = warning
-        )
-    else:
-        # Invalidate any prevously generated Kobo Auth token for this user.
-        auth_token = ub.session.query(ub.RemoteAuthToken).filter(
-            ub.RemoteAuthToken.user_id == user_id
-        ).filter(ub.RemoteAuthToken.token_type==1).first()
+    if host.startswith('127.') or host.lower() == 'localhost' or host.startswith('[::ffff:7f') or host == "[::1]":
+        warning = _('Please access Calibre-Web from non localhost to get valid api_endpoint for kobo device')

-        if not auth_token:
-            auth_token = ub.RemoteAuthToken()
-            auth_token.user_id = user_id
-            auth_token.expiration = datetime.max
-            auth_token.auth_token = (hexlify(urandom(16))).decode("utf-8")
-            auth_token.token_type = 1
+    # Generate auth token if none is existing for this user
+    auth_token = ub.session.query(ub.RemoteAuthToken).filter(
+        ub.RemoteAuthToken.user_id == user_id
+    ).filter(ub.RemoteAuthToken.token_type==1).first()

-            ub.session.add(auth_token)
-            ub.session.commit()
-        return render_title_template(
-            "generate_kobo_auth_url.html",
-            title=_(u"Kobo Setup"),
-            kobo_auth_url=url_for(
-                "kobo.TopLevelEndpoint", auth_token=auth_token.auth_token, _external=True
-            ),
-            warning = False
-        )
+    if not auth_token:
+        auth_token = ub.RemoteAuthToken()
+        auth_token.user_id = user_id
+        auth_token.expiration = datetime.max
+        auth_token.auth_token = (hexlify(urandom(16))).decode("utf-8")
+        auth_token.token_type = 1
+
+        ub.session.add(auth_token)
+        ub.session_commit()
+
+    books = calibre_db.session.query(db.Books).join(db.Data).all()
+
+    for book in books:
+        formats = [data.format for data in book.data]
+        if not 'KEPUB' in formats and config.config_kepubifypath and 'EPUB' in formats:
+            helper.convert_book_format(book.id, config.config_calibre_dir, 'EPUB', 'KEPUB', current_user.name)
+
+    return render_title_template(
+        "generate_kobo_auth_url.html",
+        title=_(u"Kobo Setup"),
+        auth_token=auth_token.auth_token,
+        warning = warning
+    )


-@kobo_auth.route("/deleteauthtoken/<int:user_id>")
+@kobo_auth.route("/deleteauthtoken/<int:user_id>", methods=["POST"])
@login_required
 def delete_auth_token(user_id):
-    # Invalidate any prevously generated Kobo Auth token for this user.
+    # Invalidate any previously generated Kobo Auth token for this user
    ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.user_id == user_id)\
        .filter(ub.RemoteAuthToken.token_type==1).delete()
-    ub.session.commit()
-    return ""
+
+    return ub.session_commit()
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+
+from flask_login import current_user
+from . import ub
+import datetime
+from sqlalchemy.sql.expression import or_, and_, true
+from sqlalchemy import exc
+
+# Add the current book id to kobo_synced_books table for current user, if entry is already present,
+# do nothing (safety precaution)
+def add_synced_books(book_id):
+    is_present = ub.session.query(ub.KoboSyncedBooks).filter(ub.KoboSyncedBooks.book_id == book_id)\
+        .filter(ub.KoboSyncedBooks.user_id == current_user.id).count()
+    if not is_present:
+        synced_book = ub.KoboSyncedBooks()
+        synced_book.user_id = current_user.id
+        synced_book.book_id = book_id
+        ub.session.add(synced_book)
+        ub.session_commit()
+
+
+# Select all entries of current book in kobo_synced_books table, which are from current user and delete them
+def remove_synced_book(book_id, all=False, session=None):
+    if not all:
+        user = ub.KoboSyncedBooks.user_id == current_user.id
+    else:
+        user = true()
+    if not session:
+        ub.session.query(ub.KoboSyncedBooks).filter(ub.KoboSyncedBooks.book_id == book_id).filter(user).delete()
+        ub.session_commit()
+    else:
+        session.query(ub.KoboSyncedBooks).filter(ub.KoboSyncedBooks.book_id == book_id).filter(user).delete()
+        ub.session_commit(sess=session)
+
+
+
+def change_archived_books(book_id, state=None, message=None):
+    archived_book = ub.session.query(ub.ArchivedBook).filter(and_(ub.ArchivedBook.user_id == int(current_user.id),
+                                                                  ub.ArchivedBook.book_id == book_id)).first()
+    if not archived_book:
+        archived_book = ub.ArchivedBook(user_id=current_user.id, book_id=book_id)
+
+    archived_book.is_archived = state if state else not archived_book.is_archived
+    archived_book.last_modified = datetime.datetime.utcnow()
+
+    ub.session.merge(archived_book)
+    ub.session_commit(message)
+    return archived_book.is_archived
+
+
+# select all books which are synced by the current user and do not belong to a synced shelf and set them to archive
+# select all shelves from current user which are synced and do not belong to the "only sync" shelves
+def update_on_sync_shelfs(user_id):
+    books_to_archive = (ub.session.query(ub.KoboSyncedBooks)
+                        .join(ub.BookShelf, ub.KoboSyncedBooks.book_id == ub.BookShelf.book_id, isouter=True)
+                        .join(ub.Shelf, ub.Shelf.user_id == user_id, isouter=True)
+                        .filter(or_(ub.Shelf.kobo_sync == 0, ub.Shelf.kobo_sync == None))
+                        .filter(ub.KoboSyncedBooks.user_id == user_id).all())
+    for b in books_to_archive:
+        change_archived_books(b.book_id, True)
+        ub.session.query(ub.KoboSyncedBooks) \
+            .filter(ub.KoboSyncedBooks.book_id == b.book_id) \
+            .filter(ub.KoboSyncedBooks.user_id == user_id).delete()
+        ub.session_commit()
+
+    # Search all shelf which are currently not synced
+    shelves_to_archive = ub.session.query(ub.Shelf).filter(ub.Shelf.user_id == user_id).filter(
+        ub.Shelf.kobo_sync == 0).all()
+    for a in shelves_to_archive:
+        ub.session.add(ub.ShelfArchive(uuid=a.uuid, user_id=user_id))
+        ub.session_commit()
@@ -16,7 +16,6 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import os
 import sys
 import inspect
@@ -41,10 +40,32 @@ logging.addLevelName(logging.WARNING, "WARN")
 logging.addLevelName(logging.CRITICAL, "CRIT")


+class _Logger(logging.Logger):
+
+    def debug_or_exception(self, message, stacklevel=2, *args, **kwargs):
+        if sys.version_info > (3, 7):
+            if is_debug_enabled():
+                self.exception(message, stacklevel=stacklevel, *args, **kwargs)
+            else:
+                self.error(message, stacklevel=stacklevel, *args, **kwargs)
+        else:
+            if is_debug_enabled():
+                self.exception(message, stack_info=True, *args, **kwargs)
+            else:
+                self.error(message, *args, **kwargs)
+
+
+    def debug_no_auth(self, message, *args, **kwargs):
+        message = message.strip("\r\n")
+        if message.startswith("send: AUTH"):
+            self.debug(message[:16], *args, **kwargs)
+        else:
+            self.debug(message, *args, **kwargs)
+
+
 def get(name=None):
    return logging.getLogger(name)

-
 def create():
    parent_frame = inspect.stack(0)[1]
    if hasattr(parent_frame, 'frame'):
@@ -54,7 +75,6 @@ def create():
    parent_module = inspect.getmodule(parent_frame)
    return get(parent_module.__name__)

-
 def is_debug_enabled():
    return logging.root.level <= logging.DEBUG

@@ -99,6 +119,7 @@ def setup(log_file, log_level=None):
    May be called multiple times.
    '''
    log_level = log_level or DEFAULT_LOG_LEVEL
+    logging.setLoggerClass(_Logger)
    logging.getLogger(__package__).setLevel(log_level)

    r = logging.root
@@ -126,11 +147,11 @@ def setup(log_file, log_level=None):
            file_handler.baseFilename = log_file
    else:
        try:
-            file_handler = RotatingFileHandler(log_file, maxBytes=50000, backupCount=2, encoding='utf-8')
+            file_handler = RotatingFileHandler(log_file, maxBytes=100000, backupCount=2, encoding='utf-8')
        except IOError:
            if log_file == DEFAULT_LOG_FILE:
                raise
-            file_handler = RotatingFileHandler(DEFAULT_LOG_FILE, maxBytes=50000, backupCount=2, encoding='utf-8')
+            file_handler = RotatingFileHandler(DEFAULT_LOG_FILE, maxBytes=100000, backupCount=2, encoding='utf-8')
            log_file = ""
    file_handler.setFormatter(FORMATTER)

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+# ComicVine api document: https://comicvine.gamespot.com/api/documentation
+
+import requests
+from cps.services.Metadata import Metadata
+
+
+class ComicVine(Metadata):
+    __name__ = "ComicVine"
+    __id__ = "comicvine"
+
+    def search(self, query, generic_cover=""):
+        val = list()
+        apikey = "57558043c53943d5d1e96a9ad425b0eb85532ee6"
+        if self.active:
+            headers = {
+                'User-Agent': 'Not Evil Browser'
+            }
+
+            result = requests.get("https://comicvine.gamespot.com/api/search?api_key="
+                                  + apikey + "&resources=issue&query=" + query + "&sort=name:desc&format=json", headers=headers)
+            for r in result.json().get('results'):
+                seriesTitle = r['volume'].get('name', "")
+                if r.get('store_date'):
+                    dateFomers = r.get('store_date')
+                else:
+                    dateFomers = r.get('date_added')
+                v = dict()
+                v['id'] = r['id']
+                v['title'] = seriesTitle + " #" + r.get('issue_number', "0") + " - " + ( r.get('name', "") or "")
+                v['authors'] = r.get('authors', [])
+                v['description'] = r.get('description', "")
+                v['publisher'] = ""
+                v['publishedDate'] = dateFomers
+                v['tags'] = ["Comics", seriesTitle]
+                v['rating'] = 0
+                v['series'] = seriesTitle
+                v['cover'] = r['image'].get('original_url')
+                v['source'] = {
+                    "id": self.__id__,
+                    "description": "ComicVine Books",
+                    "link": "https://comicvine.gamespot.com/"
+                }
+                v['url'] = r.get('site_detail_url', "")
+                val.append(v)
+        return val
+
+
@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+# Google Books api document: https://developers.google.com/books/docs/v1/using
+
+
+import requests
+from cps.services.Metadata import Metadata
+
+class Google(Metadata):
+    __name__ = "Google"
+    __id__ = "google"
+
+    def search(self, query, generic_cover=""):
+        if self.active:
+            val = list()
+            result = requests.get("https://www.googleapis.com/books/v1/volumes?q="+query.replace(" ","+"))
+            for r in result.json().get('items'):
+                v = dict()
+                v['id'] = r['id']
+                v['title'] = r['volumeInfo'].get('title',"")
+                v['authors'] = r['volumeInfo'].get('authors', [])
+                v['description'] = r['volumeInfo'].get('description', "")
+                v['publisher'] = r['volumeInfo'].get('publisher', "")
+                v['publishedDate'] = r['volumeInfo'].get('publishedDate', "")
+                v['tags'] = r['volumeInfo'].get('categories', [])
+                v['rating'] = r['volumeInfo'].get('averageRating', 0)
+                if r['volumeInfo'].get('imageLinks'):
+                    v['cover'] = r['volumeInfo']['imageLinks']['thumbnail'].replace("http://", "https://")
+                else:
+                    v['cover'] = "/../../../static/generic_cover.jpg"
+                v['source'] = {
+                    "id": self.__id__,
+                    "description": "Google Books",
+                    "link": "https://books.google.com/"}
+                v['url'] = "https://books.google.com/books?id=" + r['id']
+                val.append(v)
+            return val
+
+
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+from scholarly import scholarly
+
+from cps.services.Metadata import Metadata
+
+class scholar(Metadata):
+    __name__ = "Google Scholar"
+    __id__ = "googlescholar"
+
+    def search(self, query, generic_cover=""):
+        val = list()
+        if self.active:
+            scholar_gen = scholarly.search_pubs(' '.join(query.split('+')))
+            i = 0
+            for publication in scholar_gen:
+                v = dict()
+                v['id'] = publication['url_scholarbib'].split(':')[1]
+                v['title'] = publication['bib'].get('title')
+                v['authors'] = publication['bib'].get('author', [])
+                v['description'] = publication['bib'].get('abstract', "")
+                v['publisher'] = publication['bib'].get('venue', "")
+                if publication['bib'].get('pub_year'):
+                    v['publishedDate'] = publication['bib'].get('pub_year')+"-01-01"
+                else:
+                    v['publishedDate'] = ""
+                v['tags'] = []
+                v['rating'] = 0
+                v['series'] = ""
+                v['cover'] = ""
+                v['url'] = publication.get('pub_url') or publication.get('eprint_url') or "",
+                v['source'] = {
+                    "id": self.__id__,
+                    "description": "Google Scholar",
+                    "link": "https://scholar.google.com/"
+                }
+                val.append(v)
+                i += 1
+                if (i >= 10):
+                    break
+        return val
+
+
+
@@ -16,10 +16,8 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>

-from __future__ import division, print_function, unicode_literals
 from flask import session

-
 try:
    from flask_dance.consumer.backend.sqla import SQLAlchemyBackend, first, _get_real_user
    from sqlalchemy.orm.exc import NoResultFound
@@ -34,134 +32,131 @@ except ImportError:
    except ImportError:
        pass

-try:
-    class OAuthBackend(SQLAlchemyBackend):
-        """
-        Stores and retrieves OAuth tokens using a relational database through
-        the `SQLAlchemy`_ ORM.

-        .. _SQLAlchemy: https://www.sqlalchemy.org/
-        """
-        def __init__(self, model, session, provider_id,
-                     user=None, user_id=None, user_required=None, anon_user=None,
-                     cache=None):
-            self.provider_id = provider_id
-            super(OAuthBackend, self).__init__(model, session, user, user_id, user_required, anon_user, cache)
+class OAuthBackend(SQLAlchemyBackend):
+    """
+    Stores and retrieves OAuth tokens using a relational database through
+    the `SQLAlchemy`_ ORM.

-        def get(self, blueprint, user=None, user_id=None):
-            if self.provider_id + '_oauth_token' in session and session[self.provider_id + '_oauth_token'] != '':
-                return session[self.provider_id + '_oauth_token']
-            # check cache
-            cache_key = self.make_cache_key(blueprint=blueprint, user=user, user_id=user_id)
-            token = self.cache.get(cache_key)
-            if token:
-                return token
-
-            # if not cached, make database queries
-            query = (
-                self.session.query(self.model)
-                .filter_by(provider=self.provider_id)
-            )
-            uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
-            u = first(_get_real_user(ref, self.anon_user)
-                      for ref in (user, self.user, blueprint.config.get("user")))
-
-            use_provider_user_id = False
-            if self.provider_id + '_oauth_user_id' in session and session[self.provider_id + '_oauth_user_id'] != '':
-                query = query.filter_by(provider_user_id=session[self.provider_id + '_oauth_user_id'])
-                use_provider_user_id = True
-
-            if self.user_required and not u and not uid and not use_provider_user_id:
-                # raise ValueError("Cannot get OAuth token without an associated user")
-                return None
-            # check for user ID
-            if hasattr(self.model, "user_id") and uid:
-                query = query.filter_by(user_id=uid)
-            # check for user (relationship property)
-            elif hasattr(self.model, "user") and u:
-                query = query.filter_by(user=u)
-            # if we have the property, but not value, filter by None
-            elif hasattr(self.model, "user_id"):
-                query = query.filter_by(user_id=None)
-            # run query
-            try:
-                token = query.one().token
-            except NoResultFound:
-                token = None
-
-            # cache the result
-            self.cache.set(cache_key, token)
+    .. _SQLAlchemy: https://www.sqlalchemy.org/
+    """
+    def __init__(self, model, session, provider_id,
+                 user=None, user_id=None, user_required=None, anon_user=None,
+                 cache=None):
+        self.provider_id = provider_id
+        super(OAuthBackend, self).__init__(model, session, user, user_id, user_required, anon_user, cache)

+    def get(self, blueprint, user=None, user_id=None):
+        if self.provider_id + '_oauth_token' in session and session[self.provider_id + '_oauth_token'] != '':
+            return session[self.provider_id + '_oauth_token']
+        # check cache
+        cache_key = self.make_cache_key(blueprint=blueprint, user=user, user_id=user_id)
+        token = self.cache.get(cache_key)
+        if token:
            return token

-        def set(self, blueprint, token, user=None, user_id=None):
-            uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
-            u = first(_get_real_user(ref, self.anon_user)
-                      for ref in (user, self.user, blueprint.config.get("user")))
+        # if not cached, make database queries
+        query = (
+            self.session.query(self.model)
+            .filter_by(provider=self.provider_id)
+        )
+        uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
+        u = first(_get_real_user(ref, self.anon_user)
+                  for ref in (user, self.user, blueprint.config.get("user")))

-            if self.user_required and not u and not uid:
-                raise ValueError("Cannot set OAuth token without an associated user")
+        use_provider_user_id = False
+        if self.provider_id + '_oauth_user_id' in session and session[self.provider_id + '_oauth_user_id'] != '':
+            query = query.filter_by(provider_user_id=session[self.provider_id + '_oauth_user_id'])
+            use_provider_user_id = True

-            # if there was an existing model, delete it
-            existing_query = (
-                self.session.query(self.model)
-                .filter_by(provider=self.provider_id)
-            )
-            # check for user ID
-            has_user_id = hasattr(self.model, "user_id")
-            if has_user_id and uid:
-                existing_query = existing_query.filter_by(user_id=uid)
-            # check for user (relationship property)
-            has_user = hasattr(self.model, "user")
-            if has_user and u:
-                existing_query = existing_query.filter_by(user=u)
-            # queue up delete query -- won't be run until commit()
-            existing_query.delete()
-            # create a new model for this token
-            kwargs = {
-                "provider": self.provider_id,
-                "token": token,
-            }
-            if has_user_id and uid:
-                kwargs["user_id"] = uid
-            if has_user and u:
-                kwargs["user"] = u
-            self.session.add(self.model(**kwargs))
-            # commit to delete and add simultaneously
-            self.session.commit()
-            # invalidate cache
-            self.cache.delete(self.make_cache_key(
-                blueprint=blueprint, user=user, user_id=user_id
-            ))
+        if self.user_required and not u and not uid and not use_provider_user_id:
+            # raise ValueError("Cannot get OAuth token without an associated user")
+            return None
+        # check for user ID
+        if hasattr(self.model, "user_id") and uid:
+            query = query.filter_by(user_id=uid)
+        # check for user (relationship property)
+        elif hasattr(self.model, "user") and u:
+            query = query.filter_by(user=u)
+        # if we have the property, but not value, filter by None
+        elif hasattr(self.model, "user_id"):
+            query = query.filter_by(user_id=None)
+        # run query
+        try:
+            token = query.one().token
+        except NoResultFound:
+            token = None

-        def delete(self, blueprint, user=None, user_id=None):
-            query = (
-                self.session.query(self.model)
-                .filter_by(provider=self.provider_id)
-            )
-            uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
-            u = first(_get_real_user(ref, self.anon_user)
-                      for ref in (user, self.user, blueprint.config.get("user")))
+        # cache the result
+        self.cache.set(cache_key, token)

-            if self.user_required and not u and not uid:
-                raise ValueError("Cannot delete OAuth token without an associated user")
+        return token

-            # check for user ID
-            if hasattr(self.model, "user_id") and uid:
-                query = query.filter_by(user_id=uid)
-            # check for user (relationship property)
-            elif hasattr(self.model, "user") and u:
-                query = query.filter_by(user=u)
-            # if we have the property, but not value, filter by None
-            elif hasattr(self.model, "user_id"):
-                query = query.filter_by(user_id=None)
-            # run query
-            query.delete()
-            self.session.commit()
-            # invalidate cache
-            self.cache.delete(self.make_cache_key(
-                blueprint=blueprint, user=user, user_id=user_id,
-            ))
+    def set(self, blueprint, token, user=None, user_id=None):
+        uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
+        u = first(_get_real_user(ref, self.anon_user)
+                  for ref in (user, self.user, blueprint.config.get("user")))

-except Exception:
-    pass
+        if self.user_required and not u and not uid:
+            raise ValueError("Cannot set OAuth token without an associated user")
+
+        # if there was an existing model, delete it
+        existing_query = (
+            self.session.query(self.model)
+            .filter_by(provider=self.provider_id)
+        )
+        # check for user ID
+        has_user_id = hasattr(self.model, "user_id")
+        if has_user_id and uid:
+            existing_query = existing_query.filter_by(user_id=uid)
+        # check for user (relationship property)
+        has_user = hasattr(self.model, "user")
+        if has_user and u:
+            existing_query = existing_query.filter_by(user=u)
+        # queue up delete query -- won't be run until commit()
+        existing_query.delete()
+        # create a new model for this token
+        kwargs = {
+            "provider": self.provider_id,
+            "token": token,
+        }
+        if has_user_id and uid:
+            kwargs["user_id"] = uid
+        if has_user and u:
+            kwargs["user"] = u
+        self.session.add(self.model(**kwargs))
+        # commit to delete and add simultaneously
+        self.session.commit()
+        # invalidate cache
+        self.cache.delete(self.make_cache_key(
+            blueprint=blueprint, user=user, user_id=user_id
+        ))
+
+    def delete(self, blueprint, user=None, user_id=None):
+        query = (
+            self.session.query(self.model)
+            .filter_by(provider=self.provider_id)
+        )
+        uid = first([user_id, self.user_id, blueprint.config.get("user_id")])
+        u = first(_get_real_user(ref, self.anon_user)
+                  for ref in (user, self.user, blueprint.config.get("user")))
+
+        if self.user_required and not u and not uid:
+            raise ValueError("Cannot delete OAuth token without an associated user")
+
+        # check for user ID
+        if hasattr(self.model, "user_id") and uid:
+            query = query.filter_by(user_id=uid)
+        # check for user (relationship property)
+        elif hasattr(self.model, "user") and u:
+            query = query.filter_by(user=u)
+        # if we have the property, but not value, filter by None
+        elif hasattr(self.model, "user_id"):
+            query = query.filter_by(user_id=None)
+        # run query
+        query.delete()
+        self.session.commit()
+        # invalidate cache
+        self.cache.delete(self.make_cache_key(
+            blueprint=blueprint, user=user, user_id=user_id,
+        ))
@@ -20,7 +20,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>

-from __future__ import division, print_function, unicode_literals
 import json
 from functools import wraps

@@ -30,15 +29,20 @@ from flask_babel import gettext as _
 from flask_dance.consumer import oauth_authorized, oauth_error
 from flask_dance.contrib.github import make_github_blueprint, github
 from flask_dance.contrib.google import make_google_blueprint, google
-from flask_login import login_user, current_user
+from oauthlib.oauth2 import TokenExpiredError, InvalidGrantError
+from flask_login import login_user, current_user, login_required
 from sqlalchemy.orm.exc import NoResultFound

 from . import constants, logger, config, app, ub
-from .web import login_required
-from .oauth import OAuthBackend, backend_resultcode
+
+try:
+    from .oauth import OAuthBackend, backend_resultcode
+except NameError:
+    pass


 oauth_check = {}
+oauthblueprints = []
 oauth = Blueprint('oauth', __name__)
 log = logger.create()

@@ -84,11 +88,7 @@ def register_user_with_oauth(user=None):
            except NoResultFound:
                # no found, return error
                return
-            try:
-                ub.session.commit()
-            except Exception as e:
-                log.exception(e)
-                ub.session.rollback()
+            ub.session_commit("User {} with OAuth for provider {} registered".format(user.name, oauth_key))


 def logout_oauth_user():
@@ -97,19 +97,122 @@ def logout_oauth_user():
            session.pop(str(oauth_key) + '_oauth_user_id')


-if ub.oauth_support:
-    oauthblueprints = []
+def oauth_update_token(provider_id, token, provider_user_id):
+    session[provider_id + "_oauth_user_id"] = provider_user_id
+    session[provider_id + "_oauth_token"] = token
+
+    # Find this OAuth token in the database, or create it
+    query = ub.session.query(ub.OAuth).filter_by(
+        provider=provider_id,
+        provider_user_id=provider_user_id,
+    )
+    try:
+        oauth_entry = query.one()
+        # update token
+        oauth_entry.token = token
+    except NoResultFound:
+        oauth_entry = ub.OAuth(
+            provider=provider_id,
+            provider_user_id=provider_user_id,
+            token=token,
+        )
+    ub.session.add(oauth_entry)
+    ub.session_commit()
+
+    # Disable Flask-Dance's default behavior for saving the OAuth token
+    # Value differrs depending on flask-dance version
+    return backend_resultcode
+
+
+def bind_oauth_or_register(provider_id, provider_user_id, redirect_url, provider_name):
+    query = ub.session.query(ub.OAuth).filter_by(
+        provider=provider_id,
+        provider_user_id=provider_user_id,
+    )
+    try:
+        oauth_entry = query.first()
+        # already bind with user, just login
+        if oauth_entry.user:
+            login_user(oauth_entry.user)
+            log.debug(u"You are now logged in as: '%s'", oauth_entry.user.name)
+            flash(_(u"you are now logged in as: '%(nickname)s'", nickname= oauth_entry.user.name),
+                  category="success")
+            return redirect(url_for('web.index'))
+        else:
+            # bind to current user
+            if current_user and current_user.is_authenticated:
+                oauth_entry.user = current_user
+                try:
+                    ub.session.add(oauth_entry)
+                    ub.session.commit()
+                    flash(_(u"Link to %(oauth)s Succeeded", oauth=provider_name), category="success")
+                    log.info("Link to {} Succeeded".format(provider_name))
+                    return redirect(url_for('web.profile'))
+                except Exception as ex:
+                    log.debug_or_exception(ex)
+                    ub.session.rollback()
+            else:
+                flash(_(u"Login failed, No User Linked With OAuth Account"), category="error")
+            log.info('Login failed, No User Linked With OAuth Account')
+            return redirect(url_for('web.login'))
+            # return redirect(url_for('web.login'))
+            # if config.config_public_reg:
+            #   return redirect(url_for('web.register'))
+            # else:
+            #    flash(_(u"Public registration is not enabled"), category="error")
+            #    return redirect(url_for(redirect_url))
+    except (NoResultFound, AttributeError):
+        return redirect(url_for(redirect_url))
+
+
+def get_oauth_status():
+    status = []
+    query = ub.session.query(ub.OAuth).filter_by(
+        user_id=current_user.id,
+    )
+    try:
+        oauths = query.all()
+        for oauth_entry in oauths:
+            status.append(int(oauth_entry.provider))
+        return status
+    except NoResultFound:
+        return None
+
+
+def unlink_oauth(provider):
+    if request.host_url + 'me' != request.referrer:
+        pass
+    query = ub.session.query(ub.OAuth).filter_by(
+        provider=provider,
+        user_id=current_user.id,
+    )
+    try:
+        oauth_entry = query.one()
+        if current_user and current_user.is_authenticated:
+            oauth_entry.user = current_user
+            try:
+                ub.session.delete(oauth_entry)
+                ub.session.commit()
+                logout_oauth_user()
+                flash(_(u"Unlink to %(oauth)s Succeeded", oauth=oauth_check[provider]), category="success")
+                log.info("Unlink to {} Succeeded".format(oauth_check[provider]))
+            except Exception as ex:
+                log.debug_or_exception(ex)
+                ub.session.rollback()
+                flash(_(u"Unlink to %(oauth)s Failed", oauth=oauth_check[provider]), category="error")
+    except NoResultFound:
+        log.warning("oauth %s for user %d not found", provider, current_user.id)
+        flash(_(u"Not Linked to %(oauth)s", oauth=provider), category="error")
+    return redirect(url_for('web.profile'))
+
+def generate_oauth_blueprints():
    if not ub.session.query(ub.OAuthProvider).count():
-        oauthProvider = ub.OAuthProvider()
-        oauthProvider.provider_name = "github"
-        oauthProvider.active = False
-        ub.session.add(oauthProvider)
-        ub.session.commit()
-        oauthProvider = ub.OAuthProvider()
-        oauthProvider.provider_name = "google"
-        oauthProvider.active = False
-        ub.session.add(oauthProvider)
-        ub.session.commit()
+        for provider in ("github", "google"):
+            oauthProvider = ub.OAuthProvider()
+            oauthProvider.provider_name = provider
+            oauthProvider.active = False
+            ub.session.add(oauthProvider)
+            ub.session_commit("{} Blueprint Created".format(provider))

    oauth_ids = ub.session.query(ub.OAuthProvider).all()
    ele1 = dict(provider_name='github',
@@ -146,17 +249,23 @@ if ub.oauth_support:
        app.register_blueprint(blueprint, url_prefix="/login")
        if element['active']:
            register_oauth_blueprint(element['id'], element['provider_name'])
+    return oauthblueprints


+if ub.oauth_support:
+    oauthblueprints = generate_oauth_blueprints()
+
    @oauth_authorized.connect_via(oauthblueprints[0]['blueprint'])
    def github_logged_in(blueprint, token):
        if not token:
            flash(_(u"Failed to log in with GitHub."), category="error")
+            log.error("Failed to log in with GitHub")
            return False

        resp = blueprint.session.get("/user")
        if not resp.ok:
            flash(_(u"Failed to fetch user info from GitHub."), category="error")
+            log.error("Failed to fetch user info from GitHub")
            return False

        github_info = resp.json()
@@ -168,11 +277,13 @@ if ub.oauth_support:
    def google_logged_in(blueprint, token):
        if not token:
            flash(_(u"Failed to log in with Google."), category="error")
+            log.error("Failed to log in with Google")
            return False

        resp = blueprint.session.get("/oauth2/v2/userinfo")
        if not resp.ok:
            flash(_(u"Failed to fetch user info from Google."), category="error")
+            log.error("Failed to fetch user info from Google")
            return False

        google_info = resp.json()
@@ -180,117 +291,6 @@ if ub.oauth_support:
        return oauth_update_token(str(oauthblueprints[1]['id']), token, google_user_id)


-    def oauth_update_token(provider_id, token, provider_user_id):
-        session[provider_id + "_oauth_user_id"] = provider_user_id
-        session[provider_id + "_oauth_token"] = token
-
-        # Find this OAuth token in the database, or create it
-        query = ub.session.query(ub.OAuth).filter_by(
-            provider=provider_id,
-            provider_user_id=provider_user_id,
-        )
-        try:
-            oauth_entry = query.one()
-            # update token
-            oauth_entry.token = token
-        except NoResultFound:
-            oauth_entry = ub.OAuth(
-                provider=provider_id,
-                provider_user_id=provider_user_id,
-                token=token,
-            )
-        try:
-            ub.session.add(oauth_entry)
-            ub.session.commit()
-        except Exception as e:
-            log.exception(e)
-            ub.session.rollback()
-
-        # Disable Flask-Dance's default behavior for saving the OAuth token
-        # Value differrs depending on flask-dance version
-        return backend_resultcode
-
-
-    def bind_oauth_or_register(provider_id, provider_user_id, redirect_url, provider_name):
-        query = ub.session.query(ub.OAuth).filter_by(
-            provider=provider_id,
-            provider_user_id=provider_user_id,
-        )
-        try:
-            oauth_entry = query.first()
-            # already bind with user, just login
-            if oauth_entry.user:
-                login_user(oauth_entry.user)
-                log.debug(u"You are now logged in as: '%s'", oauth_entry.user.nickname)
-                flash(_(u"you are now logged in as: '%(nickname)s'", nickname= oauth_entry.user.nickname),
-                      category="success")
-                return redirect(url_for('web.index'))
-            else:
-                # bind to current user
-                if current_user and current_user.is_authenticated:
-                    oauth_entry.user = current_user
-                    try:
-                        ub.session.add(oauth_entry)
-                        ub.session.commit()
-                        flash(_(u"Link to %(oauth)s Succeeded", oauth=provider_name), category="success")
-                        return redirect(url_for('web.profile'))
-                    except Exception as e:
-                        log.exception(e)
-                        ub.session.rollback()
-                else:
-                    flash(_(u"Login failed, No User Linked With OAuth Account"), category="error")
-                log.info('Login failed, No User Linked With OAuth Account')
-                return redirect(url_for('web.login'))
-                # return redirect(url_for('web.login'))
-                # if config.config_public_reg:
-                #   return redirect(url_for('web.register'))
-                # else:
-                #    flash(_(u"Public registration is not enabled"), category="error")
-                #    return redirect(url_for(redirect_url))
-        except (NoResultFound, AttributeError):
-            return redirect(url_for(redirect_url))
-
-
-    def get_oauth_status():
-        status = []
-        query = ub.session.query(ub.OAuth).filter_by(
-            user_id=current_user.id,
-        )
-        try:
-            oauths = query.all()
-            for oauth_entry in oauths:
-                status.append(int(oauth_entry.provider))
-            return status
-        except NoResultFound:
-            return None
-
-
-    def unlink_oauth(provider):
-        if request.host_url + 'me' != request.referrer:
-            pass
-        query = ub.session.query(ub.OAuth).filter_by(
-            provider=provider,
-            user_id=current_user.id,
-        )
-        try:
-            oauth_entry = query.one()
-            if current_user and current_user.is_authenticated:
-                oauth_entry.user = current_user
-                try:
-                    ub.session.delete(oauth_entry)
-                    ub.session.commit()
-                    logout_oauth_user()
-                    flash(_(u"Unlink to %(oauth)s Succeeded", oauth=oauth_check[provider]), category="success")
-                except Exception as e:
-                    log.exception(e)
-                    ub.session.rollback()
-                    flash(_(u"Unlink to %(oauth)s Failed", oauth=oauth_check[provider]), category="error")
-        except NoResultFound:
-            log.warning("oauth %s for user %d not found", provider, current_user.id)
-            flash(_(u"Not Linked to %(oauth)s", oauth=provider), category="error")
-        return redirect(url_for('web.profile'))
-
-
    # notify on OAuth provider error
    @oauth_error.connect_via(oauthblueprints[0]['blueprint'])
    def github_error(blueprint, error, error_description=None, error_uri=None):
@@ -305,39 +305,6 @@ if ub.oauth_support:
        )  # ToDo: Translate
        flash(msg, category="error")

-
-    @oauth.route('/link/github')
-    @oauth_required
-    def github_login():
-        if not github.authorized:
-            return redirect(url_for('github.login'))
-        account_info = github.get('/user')
-        if account_info.ok:
-            account_info_json = account_info.json()
-            return bind_oauth_or_register(oauthblueprints[0]['id'], account_info_json['id'], 'github.login', 'github')
-        flash(_(u"GitHub Oauth error, please retry later."), category="error")
-        return redirect(url_for('web.login'))
-
-
-    @oauth.route('/unlink/github', methods=["GET"])
-    @login_required
-    def github_login_unlink():
-        return unlink_oauth(oauthblueprints[0]['id'])
-
-
-    @oauth.route('/link/google')
-    @oauth_required
-    def google_login():
-        if not google.authorized:
-            return redirect(url_for("google.login"))
-        resp = google.get("/oauth2/v2/userinfo")
-        if resp.ok:
-            account_info_json = resp.json()
-            return bind_oauth_or_register(oauthblueprints[1]['id'], account_info_json['id'], 'google.login', 'google')
-        flash(_(u"Google Oauth error, please retry later."), category="error")
-        return redirect(url_for('web.login'))
-
-
    @oauth_error.connect_via(oauthblueprints[1]['blueprint'])
    def google_error(blueprint, error, error_description=None, error_uri=None):
        msg = (
@@ -352,7 +319,49 @@ if ub.oauth_support:
        flash(msg, category="error")


-    @oauth.route('/unlink/google', methods=["GET"])
-    @login_required
-    def google_login_unlink():
-        return unlink_oauth(oauthblueprints[1]['id'])
+@oauth.route('/link/github')
+@oauth_required
+def github_login():
+    if not github.authorized:
+        return redirect(url_for('github.login'))
+    try:
+        account_info = github.get('/user')
+        if account_info.ok:
+            account_info_json = account_info.json()
+            return bind_oauth_or_register(oauthblueprints[0]['id'], account_info_json['id'], 'github.login', 'github')
+        flash(_(u"GitHub Oauth error, please retry later."), category="error")
+        log.error("GitHub Oauth error, please retry later")
+    except (InvalidGrantError, TokenExpiredError) as e:
+        flash(_(u"GitHub Oauth error: {}").format(e), category="error")
+        log.error(e)
+    return redirect(url_for('web.login'))
+
+
+@oauth.route('/unlink/github', methods=["GET"])
+@login_required
+def github_login_unlink():
+    return unlink_oauth(oauthblueprints[0]['id'])
+
+
+@oauth.route('/link/google')
+@oauth_required
+def google_login():
+    if not google.authorized:
+        return redirect(url_for("google.login"))
+    try:
+        resp = google.get("/oauth2/v2/userinfo")
+        if resp.ok:
+            account_info_json = resp.json()
+            return bind_oauth_or_register(oauthblueprints[1]['id'], account_info_json['id'], 'google.login', 'google')
+        flash(_(u"Google Oauth error, please retry later."), category="error")
+        log.error("Google Oauth error, please retry later")
+    except (InvalidGrantError, TokenExpiredError) as e:
+        flash(_(u"Google Oauth error: {}").format(e), category="error")
+        log.error(e)
+    return redirect(url_for('web.login'))
+
+
+@oauth.route('/unlink/google', methods=["GET"])
+@login_required
+def google_login_unlink():
+    return unlink_oauth(oauthblueprints[1]['id'])
@@ -20,23 +20,20 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
-import sys
 import datetime
 from functools import wraps

-from flask import Blueprint, request, render_template, Response, g, make_response
+from flask import Blueprint, request, render_template, Response, g, make_response, abort
 from flask_login import current_user
-from sqlalchemy.sql.expression import func, text, or_, and_
+from sqlalchemy.sql.expression import func, text, or_, and_, true
 from werkzeug.security import check_password_hash

 from . import constants, logger, config, db, calibre_db, ub, services, get_locale, isoLanguages
 from .helper import get_download_link, get_book_cover
 from .pagination import Pagination
-from .web import render_read_books, download_required
+from .web import render_read_books
+from .usermanagement import load_user_from_request
 from flask_babel import gettext as _
-from babel import Locale as LC
-from babel.core import UnknownLocaleError

 opds = Blueprint('opds', __name__)

@@ -51,7 +48,7 @@ def requires_basic_auth_if_no_ano(f):
            if not auth or auth.type != 'basic' or not check_auth(auth.username, auth.password):
                return authenticate()
        return f(*args, **kwargs)
-    if config.config_login_type == constants.LOGIN_LDAP and services.ldap:
+    if config.config_login_type == constants.LOGIN_LDAP and services.ldap and config.config_anonbrowse != 1:
        return services.ldap.basic_auth_required(f)
    return decorated

@@ -93,14 +90,52 @@ def feed_cc_search(query):
@opds.route("/opds/search", methods=["GET"])
@requires_basic_auth_if_no_ano
 def feed_normal_search():
-    return feed_search(request.args.get("query").strip())
+    return feed_search(request.args.get("query", "").strip())
+
+
+@opds.route("/opds/books")
+@requires_basic_auth_if_no_ano
+def feed_booksindex():
+    shift = 0
+    off = int(request.args.get("offset") or 0)
+    entries = calibre_db.session.query(func.upper(func.substr(db.Books.sort, 1, 1)).label('id'))\
+        .filter(calibre_db.common_filters()).group_by(func.upper(func.substr(db.Books.sort, 1, 1))).all()
+
+    elements = []
+    if off == 0:
+        elements.append({'id': "00", 'name':_("All")})
+        shift = 1
+    for entry in entries[
+                 off + shift - 1:
+                 int(off + int(config.config_books_per_page) - shift)]:
+        elements.append({'id': entry.id, 'name': entry.id})
+
+    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
+                            len(entries) + 1)
+    return render_xml_template('feed.xml',
+                               letterelements=elements,
+                               folder='opds.feed_letter_books',
+                               pagination=pagination)
+
+
+@opds.route("/opds/books/letter/<book_id>")
+@requires_basic_auth_if_no_ano
+def feed_letter_books(book_id):
+    off = request.args.get("offset") or 0
+    letter = true() if book_id == "00" else func.upper(db.Books.sort).startswith(book_id)
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
+                                                        db.Books,
+                                                        letter,
+                                                        [db.Books.sort])
+
+    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@opds.route("/opds/new")
@requires_basic_auth_if_no_ano
 def feed_new():
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books, True, [db.Books.timestamp.desc()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)

@@ -118,7 +153,7 @@ def feed_discover():
@requires_basic_auth_if_no_ano
 def feed_best_rated():
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books, db.Books.ratings.any(db.Ratings.rating > 9),
                                                        [db.Books.timestamp.desc()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)
@@ -149,14 +184,41 @@ def feed_hot():
@opds.route("/opds/author")
@requires_basic_auth_if_no_ano
 def feed_authorindex():
-    off = request.args.get("offset") or 0
-    entries = calibre_db.session.query(db.Authors).join(db.books_authors_link).join(db.Books)\
-        .filter(calibre_db.common_filters())\
-        .group_by(text('books_authors_link.author'))\
-        .order_by(db.Authors.sort).limit(config.config_books_per_page)\
-        .offset(off)
+    shift = 0
+    off = int(request.args.get("offset") or 0)
+    entries = calibre_db.session.query(func.upper(func.substr(db.Authors.sort, 1, 1)).label('id'))\
+        .join(db.books_authors_link).join(db.Books).filter(calibre_db.common_filters())\
+        .group_by(func.upper(func.substr(db.Authors.sort, 1, 1))).all()
+
+    elements = []
+    if off == 0:
+        elements.append({'id': "00", 'name':_("All")})
+        shift = 1
+    for entry in entries[
+                 off + shift - 1:
+                 int(off + int(config.config_books_per_page) - shift)]:
+        elements.append({'id': entry.id, 'name': entry.id})
+
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(calibre_db.session.query(db.Authors).all()))
+                            len(entries) + 1)
+    return render_xml_template('feed.xml',
+                               letterelements=elements,
+                               folder='opds.feed_letter_author',
+                               pagination=pagination)
+
+
+@opds.route("/opds/author/letter/<book_id>")
+@requires_basic_auth_if_no_ano
+def feed_letter_author(book_id):
+    off = request.args.get("offset") or 0
+    letter = true() if book_id == "00" else func.upper(db.Authors.sort).startswith(book_id)
+    entries = calibre_db.session.query(db.Authors).join(db.books_authors_link).join(db.Books)\
+        .filter(calibre_db.common_filters()).filter(letter)\
+        .group_by(text('books_authors_link.author'))\
+        .order_by(db.Authors.sort)
+    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
+                            entries.count())
+    entries = entries.limit(config.config_books_per_page).offset(off).all()
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_author', pagination=pagination)


@@ -164,7 +226,7 @@ def feed_authorindex():
@requires_basic_auth_if_no_ano
 def feed_author(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.authors.any(db.Authors.id == book_id),
                                                        [db.Books.timestamp.desc()])
@@ -190,7 +252,7 @@ def feed_publisherindex():
@requires_basic_auth_if_no_ano
 def feed_publisher(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.publishers.any(db.Publishers.id == book_id),
                                                        [db.Books.timestamp.desc()])
@@ -200,17 +262,41 @@ def feed_publisher(book_id):
@opds.route("/opds/category")
@requires_basic_auth_if_no_ano
 def feed_categoryindex():
+    shift = 0
+    off = int(request.args.get("offset") or 0)
+    entries = calibre_db.session.query(func.upper(func.substr(db.Tags.name, 1, 1)).label('id'))\
+        .join(db.books_tags_link).join(db.Books).filter(calibre_db.common_filters())\
+        .group_by(func.upper(func.substr(db.Tags.name, 1, 1))).all()
+    elements = []
+    if off == 0:
+        elements.append({'id': "00", 'name':_("All")})
+        shift = 1
+    for entry in entries[
+                 off + shift - 1:
+                 int(off + int(config.config_books_per_page) - shift)]:
+        elements.append({'id': entry.id, 'name': entry.id})
+
+    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
+                            len(entries) + 1)
+    return render_xml_template('feed.xml',
+                               letterelements=elements,
+                               folder='opds.feed_letter_category',
+                               pagination=pagination)
+
+@opds.route("/opds/category/letter/<book_id>")
+@requires_basic_auth_if_no_ano
+def feed_letter_category(book_id):
    off = request.args.get("offset") or 0
+    letter = true() if book_id == "00" else func.upper(db.Tags.name).startswith(book_id)
    entries = calibre_db.session.query(db.Tags)\
        .join(db.books_tags_link)\
        .join(db.Books)\
-        .filter(calibre_db.common_filters())\
+        .filter(calibre_db.common_filters()).filter(letter)\
        .group_by(text('books_tags_link.tag'))\
-        .order_by(db.Tags.name)\
-        .offset(off)\
-        .limit(config.config_books_per_page)
+        .order_by(db.Tags.name)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(calibre_db.session.query(db.Tags).all()))
+                            entries.count())
+    entries = entries.offset(off).limit(config.config_books_per_page).all()
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_category', pagination=pagination)


@@ -218,7 +304,7 @@ def feed_categoryindex():
@requires_basic_auth_if_no_ano
 def feed_category(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.tags.any(db.Tags.id == book_id),
                                                        [db.Books.timestamp.desc()])
@@ -228,16 +314,40 @@ def feed_category(book_id):
@opds.route("/opds/series")
@requires_basic_auth_if_no_ano
 def feed_seriesindex():
+    shift = 0
+    off = int(request.args.get("offset") or 0)
+    entries = calibre_db.session.query(func.upper(func.substr(db.Series.sort, 1, 1)).label('id'))\
+        .join(db.books_series_link).join(db.Books).filter(calibre_db.common_filters())\
+        .group_by(func.upper(func.substr(db.Series.sort, 1, 1))).all()
+    elements = []
+    if off == 0:
+        elements.append({'id': "00", 'name':_("All")})
+        shift = 1
+    for entry in entries[
+                 off + shift - 1:
+                 int(off + int(config.config_books_per_page) - shift)]:
+        elements.append({'id': entry.id, 'name': entry.id})
+    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
+                            len(entries) + 1)
+    return render_xml_template('feed.xml',
+                               letterelements=elements,
+                               folder='opds.feed_letter_series',
+                               pagination=pagination)
+
+@opds.route("/opds/series/letter/<book_id>")
+@requires_basic_auth_if_no_ano
+def feed_letter_series(book_id):
    off = request.args.get("offset") or 0
+    letter = true() if book_id == "00" else func.upper(db.Series.sort).startswith(book_id)
    entries = calibre_db.session.query(db.Series)\
        .join(db.books_series_link)\
        .join(db.Books)\
-        .filter(calibre_db.common_filters())\
+        .filter(calibre_db.common_filters()).filter(letter)\
        .group_by(text('books_series_link.series'))\
-        .order_by(db.Series.sort)\
-        .offset(off).all()
+        .order_by(db.Series.sort)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(calibre_db.session.query(db.Series).all()))
+                            entries.count())
+    entries = entries.offset(off).limit(config.config_books_per_page).all()
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_series', pagination=pagination)


@@ -245,7 +355,7 @@ def feed_seriesindex():
@requires_basic_auth_if_no_ano
 def feed_series(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.series.any(db.Series.id == book_id),
                                                        [db.Books.series_index])
@@ -268,7 +378,7 @@ def feed_ratingindex():
                            len(entries))
    element = list()
    for entry in entries:
-        element.append(FeedObject(entry[0].id, "{} Stars".format(entry.name)))
+        element.append(FeedObject(entry[0].id, _("{} Stars").format(entry.name)))
    return render_xml_template('feed.xml', listelements=element, folder='opds.feed_ratings', pagination=pagination)


@@ -276,7 +386,7 @@ def feed_ratingindex():
@requires_basic_auth_if_no_ano
 def feed_ratings(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.ratings.any(db.Ratings.id == book_id),
                                                        [db.Books.timestamp.desc()])
@@ -304,7 +414,7 @@ def feed_formatindex():
@requires_basic_auth_if_no_ano
 def feed_format(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.data.any(db.Data.format == book_id.upper()),
                                                        [db.Books.timestamp.desc()])
@@ -319,16 +429,17 @@ def feed_languagesindex():
    if current_user.filter_language() == u"all":
        languages = calibre_db.speaking_language()
    else:
-        try:
-            cur_l = LC.parse(current_user.filter_language())
-        except UnknownLocaleError:
-            cur_l = None
+        #try:
+        #    cur_l = LC.parse(current_user.filter_language())
+        #except UnknownLocaleError:
+        #    cur_l = None
        languages = calibre_db.session.query(db.Languages).filter(
            db.Languages.lang_code == current_user.filter_language()).all()
-        if cur_l:
-            languages[0].name = cur_l.get_language_name(get_locale())
-        else:
-            languages[0].name = _(isoLanguages.get(part3=languages[0].lang_code).name)
+        languages[0].name = isoLanguages.get_language_name(get_locale(), languages[0].lang_code)
+        #if cur_l:
+        #    languages[0].name = cur_l.get_language_name(get_locale())
+        #else:
+        #    languages[0].name = _(isoLanguages.get(part3=languages[0].lang_code).name)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
                            len(languages))
    return render_xml_template('feed.xml', listelements=languages, folder='opds.feed_languages', pagination=pagination)
@@ -338,7 +449,7 @@ def feed_languagesindex():
@requires_basic_auth_if_no_ano
 def feed_languages(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
+    entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                        db.Books,
                                                        db.Books.languages.any(db.Languages.id == book_id),
                                                        [db.Books.timestamp.desc()])
@@ -383,8 +494,13 @@ def feed_shelf(book_id):

@opds.route("/opds/download/<book_id>/<book_format>/")
@requires_basic_auth_if_no_ano
-@download_required
 def opds_download_link(book_id, book_format):
+    # I gave up with this: With enabled ldap login, the user doesn't get logged in, therefore it's always guest
+    # workaround, loading the user from the request and checking it's download rights here
+    # in case of anonymous browsing user is None
+    user = load_user_from_request(request) or current_user
+    if not user.role_download():
+        return abort(403)
    if "Kobo" in request.headers.get('User-Agent'):
        client = "kobo"
    else:
@@ -408,7 +524,7 @@ def get_metadata_calibre_companion(uuid, library):

 def feed_search(term):
    if term:
-        entries = calibre_db.get_search_results(term)
+        entries, __, ___ = calibre_db.get_search_results(term)
        entriescount = len(entries) if len(entries) > 0 else 1
        pagination = Pagination(1, entriescount, entriescount)
        return render_xml_template('feed.xml', searchterm=term, entries=entries, pagination=pagination)
@@ -417,11 +533,18 @@ def feed_search(term):


 def check_auth(username, password):
-    if sys.version_info.major == 3:
+    try:
        username = username.encode('windows-1252')
-    user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) ==
+    except UnicodeEncodeError:
+        username = username.encode('utf-8')
+    user = ub.session.query(ub.User).filter(func.lower(ub.User.name) ==
                                            username.decode('utf-8').lower()).first()
-    return bool(user and check_password_hash(str(user.password), password))
+    if bool(user and check_password_hash(str(user.password), password)):
+        return True
+    else:
+        ip_Address = request.headers.get('X-Forwarded-For', request.remote_addr)
+        log.warning('OPDS Login failed for user "%s" IP-address: %s', username.decode('utf-8'), ip_Address)
+        return False


 def authenticate():
@@ -20,7 +20,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 from math import ceil


@@ -27,11 +27,8 @@

 # http://flask.pocoo.org/snippets/62/

-from __future__ import division, print_function, unicode_literals
-try:
-    from urllib.parse import urlparse, urljoin
-except ImportError:
-    from urlparse import urlparse, urljoin
+from urllib.parse import urlparse, urljoin
+

 from flask import request, url_for, redirect

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2018-2019 OzzieIsaacs, cervinko, jkrehm, bodybybuddha, ok11,
+#                            andy29485, idalin, Kyosfonica, wuqi, Kennyl, lemmsh,
+#                            falgh1, grunjol, csitko, ytils, xybydy, trasba, vrabe,
+#                            ruben-herold, marblepebble, JackED42, SiphonSquirrel,
+#                            apetresc, nanu-c, mutschler
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import json
+from datetime import datetime
+
+from flask import Blueprint, request, make_response, abort, url_for, flash, redirect
+from flask_login import login_required, current_user, login_user
+from flask_babel import gettext as _
+from sqlalchemy.sql.expression import true
+
+from . import config, logger, ub
+from .render_template import render_title_template
+
+try:
+    from functools import wraps
+except ImportError:
+    pass  # We're not using Python 3
+
+remotelogin = Blueprint('remotelogin', __name__)
+log = logger.create()
+
+
+def remote_login_required(f):
+    @wraps(f)
+    def inner(*args, **kwargs):
+        if config.config_remote_login:
+            return f(*args, **kwargs)
+        if request.headers.get('X-Requested-With') == 'XMLHttpRequest':
+            data = {'status': 'error', 'message': 'Forbidden'}
+            response = make_response(json.dumps(data, ensure_ascii=False))
+            response.headers["Content-Type"] = "application/json; charset=utf-8"
+            return response, 403
+        abort(403)
+
+    return inner
+
+@remotelogin.route('/remote/login')
+@remote_login_required
+def remote_login():
+    auth_token = ub.RemoteAuthToken()
+    ub.session.add(auth_token)
+    ub.session_commit()
+    verify_url = url_for('remotelogin.verify_token', token=auth_token.auth_token, _external=true)
+    log.debug(u"Remot Login request with token: %s", auth_token.auth_token)
+    return render_title_template('remote_login.html', title=_(u"Login"), token=auth_token.auth_token,
+                                 verify_url=verify_url, page="remotelogin")
+
+
+@remotelogin.route('/verify/<token>')
+@remote_login_required
+@login_required
+def verify_token(token):
+    auth_token = ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first()
+
+    # Token not found
+    if auth_token is None:
+        flash(_(u"Token not found"), category="error")
+        log.error(u"Remote Login token not found")
+        return redirect(url_for('web.index'))
+
+    # Token expired
+    elif datetime.now() > auth_token.expiration:
+        ub.session.delete(auth_token)
+        ub.session_commit()
+
+        flash(_(u"Token has expired"), category="error")
+        log.error(u"Remote Login token expired")
+        return redirect(url_for('web.index'))
+
+    # Update token with user information
+    auth_token.user_id = current_user.id
+    auth_token.verified = True
+    ub.session_commit()
+
+    flash(_(u"Success! Please return to your device"), category="success")
+    log.debug(u"Remote Login token for userid %s verified", auth_token.user_id)
+    return redirect(url_for('web.index'))
+
+
+@remotelogin.route('/ajax/verify_token', methods=['POST'])
+@remote_login_required
+def token_verified():
+    token = request.form['token']
+    auth_token = ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first()
+
+    data = {}
+
+    # Token not found
+    if auth_token is None:
+        data['status'] = 'error'
+        data['message'] = _(u"Token not found")
+
+    # Token expired
+    elif datetime.now() > auth_token.expiration:
+        ub.session.delete(auth_token)
+        ub.session_commit()
+
+        data['status'] = 'error'
+        data['message'] = _(u"Token has expired")
+
+    elif not auth_token.verified:
+        data['status'] = 'not_verified'
+
+    else:
+        user = ub.session.query(ub.User).filter(ub.User.id == auth_token.user_id).first()
+        login_user(user)
+
+        ub.session.delete(auth_token)
+        ub.session_commit("User {} logged in via remotelogin, token deleted".format(user.name))
+
+        data['status'] = 'success'
+        log.debug(u"Remote Login for userid %s succeded", user.id)
+        flash(_(u"you are now logged in as: '%(nickname)s'", nickname=user.name), category="success")
+
+    response = make_response(json.dumps(data, ensure_ascii=False))
+    response.headers["Content-Type"] = "application/json; charset=utf-8"
+
+    return response
@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2018-2020 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+from flask import render_template
+from flask_babel import gettext as _
+from flask import g
+from werkzeug.local import LocalProxy
+from flask_login import current_user
+
+from . import config, constants, ub, logger, db, calibre_db
+from .ub import User
+
+
+log = logger.create()
+
+def get_sidebar_config(kwargs=None):
+    kwargs = kwargs or []
+    if 'content' in kwargs:
+        content = kwargs['content']
+        content = isinstance(content, (User, LocalProxy)) and not content.role_anonymous()
+    else:
+        content = 'conf' in kwargs
+    sidebar = list()
+    sidebar.append({"glyph": "glyphicon-book", "text": _('Books'), "link": 'web.index', "id": "new",
+                    "visibility": constants.SIDEBAR_RECENT, 'public': True, "page": "root",
+                    "show_text": _('Show recent books'), "config_show":False})
+    sidebar.append({"glyph": "glyphicon-fire", "text": _('Hot Books'), "link": 'web.books_list', "id": "hot",
+                    "visibility": constants.SIDEBAR_HOT, 'public': True, "page": "hot",
+                    "show_text": _('Show Hot Books'), "config_show": True})
+    if current_user.role_admin():
+        sidebar.append({"glyph": "glyphicon-download", "text": _('Downloaded Books'), "link": 'web.download_list',
+                        "id": "download", "visibility": constants.SIDEBAR_DOWNLOAD, 'public': (not g.user.is_anonymous),
+                        "page": "download", "show_text": _('Show Downloaded Books'),
+                        "config_show": content})
+    else:
+        sidebar.append({"glyph": "glyphicon-download", "text": _('Downloaded Books'), "link": 'web.books_list',
+                        "id": "download", "visibility": constants.SIDEBAR_DOWNLOAD, 'public': (not g.user.is_anonymous),
+                        "page": "download", "show_text": _('Show Downloaded Books'),
+                        "config_show": content})
+    sidebar.append(
+        {"glyph": "glyphicon-star", "text": _('Top Rated Books'), "link": 'web.books_list', "id": "rated",
+         "visibility": constants.SIDEBAR_BEST_RATED, 'public': True, "page": "rated",
+         "show_text": _('Show Top Rated Books'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-eye-open", "text": _('Read Books'), "link": 'web.books_list', "id": "read",
+                    "visibility": constants.SIDEBAR_READ_AND_UNREAD, 'public': (not g.user.is_anonymous),
+                    "page": "read", "show_text": _('Show read and unread'), "config_show": content})
+    sidebar.append(
+        {"glyph": "glyphicon-eye-close", "text": _('Unread Books'), "link": 'web.books_list', "id": "unread",
+         "visibility": constants.SIDEBAR_READ_AND_UNREAD, 'public': (not g.user.is_anonymous), "page": "unread",
+         "show_text": _('Show unread'), "config_show": False})
+    sidebar.append({"glyph": "glyphicon-random", "text": _('Discover'), "link": 'web.books_list', "id": "rand",
+                    "visibility": constants.SIDEBAR_RANDOM, 'public': True, "page": "discover",
+                    "show_text": _('Show Random Books'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-inbox", "text": _('Categories'), "link": 'web.category_list', "id": "cat",
+                    "visibility": constants.SIDEBAR_CATEGORY, 'public': True, "page": "category",
+                    "show_text": _('Show category selection'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-bookmark", "text": _('Series'), "link": 'web.series_list', "id": "serie",
+                    "visibility": constants.SIDEBAR_SERIES, 'public': True, "page": "series",
+                    "show_text": _('Show series selection'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-user", "text": _('Authors'), "link": 'web.author_list', "id": "author",
+                    "visibility": constants.SIDEBAR_AUTHOR, 'public': True, "page": "author",
+                    "show_text": _('Show author selection'), "config_show": True})
+    sidebar.append(
+        {"glyph": "glyphicon-text-size", "text": _('Publishers'), "link": 'web.publisher_list', "id": "publisher",
+         "visibility": constants.SIDEBAR_PUBLISHER, 'public': True, "page": "publisher",
+         "show_text": _('Show publisher selection'), "config_show":True})
+    sidebar.append({"glyph": "glyphicon-flag", "text": _('Languages'), "link": 'web.language_overview', "id": "lang",
+                    "visibility": constants.SIDEBAR_LANGUAGE, 'public': (g.user.filter_language() == 'all'),
+                    "page": "language",
+                    "show_text": _('Show language selection'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-star-empty", "text": _('Ratings'), "link": 'web.ratings_list', "id": "rate",
+                    "visibility": constants.SIDEBAR_RATING, 'public': True,
+                    "page": "rating", "show_text": _('Show ratings selection'), "config_show": True})
+    sidebar.append({"glyph": "glyphicon-file", "text": _('File formats'), "link": 'web.formats_list', "id": "format",
+                    "visibility": constants.SIDEBAR_FORMAT, 'public': True,
+                    "page": "format", "show_text": _('Show file formats selection'), "config_show": True})
+    sidebar.append(
+        {"glyph": "glyphicon-trash", "text": _('Archived Books'), "link": 'web.books_list', "id": "archived",
+         "visibility": constants.SIDEBAR_ARCHIVED, 'public': (not g.user.is_anonymous), "page": "archived",
+         "show_text": _('Show archived books'), "config_show": content})
+    sidebar.append(
+        {"glyph": "glyphicon-th-list", "text": _('Books List'), "link": 'web.books_table', "id": "list",
+         "visibility": constants.SIDEBAR_LIST, 'public': (not g.user.is_anonymous), "page": "list",
+         "show_text": _('Show Books List'), "config_show": content})
+
+    return sidebar
+
+def get_readbooks_ids():
+    if not config.config_read_column:
+        readBooks = ub.session.query(ub.ReadBook).filter(ub.ReadBook.user_id == int(current_user.id))\
+            .filter(ub.ReadBook.read_status == ub.ReadBook.STATUS_FINISHED).all()
+        return frozenset([x.book_id for x in readBooks])
+    else:
+        try:
+            readBooks = calibre_db.session.query(db.cc_classes[config.config_read_column])\
+                .filter(db.cc_classes[config.config_read_column].value == True).all()
+            return frozenset([x.book for x in readBooks])
+        except (KeyError, AttributeError):
+            log.error("Custom Column No.%d is not existing in calibre database", config.config_read_column)
+            return []
+
+# Returns the template for rendering and includes the instance name
+def render_title_template(*args, **kwargs):
+    sidebar = get_sidebar_config(kwargs)
+    return render_template(instance=config.config_calibre_web_title, sidebar=sidebar,
+                           accept=constants.EXTENSIONS_UPLOAD, read_book_ids=get_readbooks_ids(),
+                           *args, **kwargs)
@@ -36,8 +36,6 @@
 #
 # Inspired by http://flask.pocoo.org/snippets/35/

-from __future__ import division, print_function, unicode_literals
-

 class ReverseProxied(object):
    """Wrap the application in this middleware and configure the
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import os
+import json
+import importlib
+import sys
+import inspect
+import datetime
+import concurrent.futures
+
+from flask import Blueprint, request, Response, url_for
+from flask_login import current_user
+from flask_login import login_required
+from sqlalchemy.orm.attributes import flag_modified
+from sqlalchemy.exc import OperationalError, InvalidRequestError
+
+from . import constants, logger, ub
+from cps.services.Metadata import Metadata
+
+
+meta = Blueprint('metadata', __name__)
+
+log = logger.create()
+
+new_list = list()
+meta_dir = os.path.join(constants.BASE_DIR, "cps", "metadata_provider")
+modules = os.listdir(os.path.join(constants.BASE_DIR, "cps", "metadata_provider"))
+for f in modules:
+    if os.path.isfile(os.path.join(meta_dir, f)) and not f.endswith('__init__.py'):
+        a = os.path.basename(f)[:-3]
+        try:
+            importlib.import_module("cps.metadata_provider." + a)
+            new_list.append(a)
+        except ImportError:
+            log.error("Import error for metadata source: {}".format(a))
+            pass
+
+def list_classes(provider_list):
+    classes = list()
+    for element in provider_list:
+        for name, obj in inspect.getmembers(sys.modules["cps.metadata_provider." + element]):
+            if inspect.isclass(obj) and name != "Metadata" and issubclass(obj, Metadata):
+                classes.append(obj())
+    return classes
+
+cl = list_classes(new_list)
+
+@meta.route("/metadata/provider")
+@login_required
+def metadata_provider():
+    active = current_user.view_settings.get('metadata', {})
+    provider = list()
+    for c in cl:
+        ac = active.get(c.__id__, True)
+        provider.append({"name": c.__name__, "active": ac, "initial": ac, "id": c.__id__})
+    return Response(json.dumps(provider), mimetype='application/json')
+
+@meta.route("/metadata/provider", methods=['POST'])
+@meta.route("/metadata/provider/<prov_name>", methods=['POST'])
+@login_required
+def metadata_change_active_provider(prov_name):
+    new_state = request.get_json()
+    active = current_user.view_settings.get('metadata', {})
+    active[new_state['id']] = new_state['value']
+    current_user.view_settings['metadata'] = active
+    try:
+        try:
+            flag_modified(current_user, "view_settings")
+        except AttributeError:
+            pass
+        ub.session.commit()
+    except (InvalidRequestError, OperationalError):
+        log.error("Invalid request received: {}".format(request))
+        return "Invalid request", 400
+    if "initial" in new_state and prov_name:
+        for c in cl:
+            if c.__id__ == prov_name:
+                data = c.search(new_state.get('query', ""))
+                break
+        return Response(json.dumps(data), mimetype='application/json')
+    return ""
+
+@meta.route("/metadata/search", methods=['POST'])
+@login_required
+def metadata_search():
+    query = request.form.to_dict().get('query')
+    data = list()
+    active = current_user.view_settings.get('metadata', {})
+    if query:
+        generic_cover = ""
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            meta = {executor.submit(c.search, query, generic_cover): c for c in cl if active.get(c.__id__, True)}
+            for future in concurrent.futures.as_completed(meta):
+                data.extend(future.result())
+    return Response(json.dumps(data), mimetype='application/json')
+
+
+
+
+
+
@@ -16,17 +16,19 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import sys
 import os
 import errno
 import signal
 import socket
+import subprocess  # nosec

 try:
    from gevent.pywsgi import WSGIServer
    from gevent.pool import Pool
    from gevent import __version__ as _version
+    from greenlet import GreenletExit
+    import ssl
    VERSION = 'Gevent ' + _version
    _GEVENT = True
 except ImportError:
@@ -134,6 +136,64 @@ class WebServer(object):

        return sock, _readable_listen_address(*address)

+    @staticmethod
+    def _get_args_for_reloading():
+        """Determine how the script was executed, and return the args needed
+        to execute it again in a new process.
+        Code from https://github.com/pyload/pyload. Author GammaC0de, voulter
+        """
+        rv = [sys.executable]
+        py_script = sys.argv[0]
+        args = sys.argv[1:]
+        # Need to look at main module to determine how it was executed.
+        __main__ = sys.modules["__main__"]
+
+        # The value of __package__ indicates how Python was called. It may
+        # not exist if a setuptools script is installed as an egg. It may be
+        # set incorrectly for entry points created with pip on Windows.
+        if getattr(__main__, "__package__", None) is None or (
+            os.name == "nt"
+            and __main__.__package__ == ""
+            and not os.path.exists(py_script)
+            and os.path.exists("{}.exe".format(py_script))
+        ):
+            # Executed a file, like "python app.py".
+            py_script = os.path.abspath(py_script)
+
+            if os.name == "nt":
+                # Windows entry points have ".exe" extension and should be
+                # called directly.
+                if not os.path.exists(py_script) and os.path.exists("{}.exe".format(py_script)):
+                    py_script += ".exe"
+
+                if (
+                        os.path.splitext(sys.executable)[1] == ".exe"
+                        and os.path.splitext(py_script)[1] == ".exe"
+                ):
+                    rv.pop(0)
+
+            rv.append(py_script)
+        else:
+            # Executed a module, like "python -m module".
+            if sys.argv[0] == "-m":
+                args = sys.argv
+            else:
+                if os.path.isfile(py_script):
+                    # Rewritten by Python from "-m script" to "/path/to/script.py".
+                    py_module = __main__.__package__
+                    name = os.path.splitext(os.path.basename(py_script))[0]
+
+                    if name != "__main__":
+                        py_module += ".{}".format(name)
+                else:
+                    # Incorrectly rewritten by pydevd debugger from "-m script" to "script".
+                    py_module = py_script
+
+                rv.extend(("-m", py_module.lstrip(".")))
+
+        rv.extend(args)
+        return rv
+
    def _start_gevent(self):
        ssl_args = self.ssl_args or {}

@@ -143,6 +203,16 @@ class WebServer(object):
                output = _readable_listen_address(self.listen_address, self.listen_port)
            log.info('Starting Gevent server on %s', output)
            self.wsgiserver = WSGIServer(sock, self.app, log=self.access_logger, spawn=Pool(), **ssl_args)
+            if ssl_args:
+                wrap_socket = self.wsgiserver.wrap_socket
+                def my_wrap_socket(*args, **kwargs):
+                    try:
+                        return wrap_socket(*args, **kwargs)
+                    except (ssl.SSLError, OSError) as ex:
+                        log.warning('Gevent SSL Error: %s', ex)
+                        raise GreenletExit
+
+                self.wsgiserver.wrap_socket = my_wrap_socket
            self.wsgiserver.serve_forever()
        finally:
            if self.unix_socket_file:
@@ -180,18 +250,16 @@ class WebServer(object):
        finally:
            self.wsgiserver = None

+        # prevent irritating log of pending tasks message from asyncio
+        logger.get('asyncio').setLevel(logger.logging.CRITICAL)
+
        if not self.restart:
            log.info("Performing shutdown of Calibre-Web")
-            # prevent irritiating log of pending tasks message from asyncio
-            logger.get('asyncio').setLevel(logger.logging.CRITICAL)
            return True

        log.info("Performing restart of Calibre-Web")
-        arguments = list(sys.argv)
-        arguments.insert(0, sys.executable)
-        if os.name == 'nt':
-            arguments = ["\"%s\"" % a for a in arguments]
-        os.execv(sys.executable, arguments)
+        args = self._get_args_for_reloading()
+        subprocess.call(args, close_fds=True)  # nosec
        return True

    def _killServer(self, __, ___):
@@ -200,9 +268,6 @@ class WebServer(object):
    def stop(self, restart=False):
        from . import updater_thread
        updater_thread.stop()
-        from . import calibre_db
-        calibre_db.stop()
-

        log.info("webserver stop (restart=%s)", restart)
        self.restart = restart
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+
+class Metadata():
+    __name__ = "Generic"
+
+    def __init__(self):
+        self.active = True
+
+    def set_status(self, state):
+        self.active = state
@@ -21,10 +21,8 @@ import sys
 from base64 import b64decode, b64encode
 from jsonschema import validate, exceptions, __version__
 from datetime import datetime
-try:
-    from urllib import unquote
-except ImportError:
-    from urllib.parse import unquote
+
+from urllib.parse import unquote

 from flask import json
 from .. import logger
@@ -34,10 +32,7 @@ log = logger.create()


 def b64encode_json(json_data):
-    if sys.version_info < (3, 0):
-        return b64encode(json.dumps(json_data))
-    else:
-        return b64encode(json.dumps(json_data).encode())
+    return b64encode(json.dumps(json_data).encode())


 # Python3 has a timestamp() method we could be calling, however it's not avaiable in python2.
@@ -64,7 +59,7 @@ class SyncToken:
        books_last_modified: Datetime representing the last modified book that the device knows about.
    """

-    SYNC_TOKEN_HEADER = "x-kobo-synctoken"
+    SYNC_TOKEN_HEADER = "x-kobo-synctoken"  # nosec
    VERSION = "1-1-0"
    LAST_MODIFIED_ADDED_VERSION = "1-1-0"
    MIN_VERSION = "1-0-0"
@@ -84,7 +79,8 @@ class SyncToken:
            "books_last_created": {"type": "string"},
            "archive_last_modified": {"type": "string"},
            "reading_state_last_modified": {"type": "string"},
-            "tags_last_modified": {"type": "string"},
+            "tags_last_modified": {"type": "string"}
+            # "books_last_id": {"type": "integer", "optional": True}
        },
    }

@@ -95,19 +91,21 @@ class SyncToken:
        books_last_modified=datetime.min,
        archive_last_modified=datetime.min,
        reading_state_last_modified=datetime.min,
-        tags_last_modified=datetime.min,
-    ):
+        tags_last_modified=datetime.min
+        # books_last_id=-1
+    ):  # nosec
        self.raw_kobo_store_token = raw_kobo_store_token
        self.books_last_created = books_last_created
        self.books_last_modified = books_last_modified
        self.archive_last_modified = archive_last_modified
        self.reading_state_last_modified = reading_state_last_modified
        self.tags_last_modified = tags_last_modified
+        # self.books_last_id = books_last_id

    @staticmethod
    def from_headers(headers):
        sync_token_header = headers.get(SyncToken.SYNC_TOKEN_HEADER, "")
-        if sync_token_header == "":
+        if sync_token_header == "":  # nosec
            return SyncToken()

        # On the first sync from a Kobo device, we may receive the SyncToken
@@ -137,9 +135,12 @@ class SyncToken:
            archive_last_modified = get_datetime_from_json(data_json, "archive_last_modified")
            reading_state_last_modified = get_datetime_from_json(data_json, "reading_state_last_modified")
            tags_last_modified = get_datetime_from_json(data_json, "tags_last_modified")
+            # books_last_id = data_json["books_last_id"]
        except TypeError:
            log.error("SyncToken timestamps don't parse to a datetime.")
            return SyncToken(raw_kobo_store_token=raw_kobo_store_token)
+        #except KeyError:
+        #    books_last_id = -1

        return SyncToken(
            raw_kobo_store_token=raw_kobo_store_token,
@@ -147,7 +148,8 @@ class SyncToken:
            books_last_modified=books_last_modified,
            archive_last_modified=archive_last_modified,
            reading_state_last_modified=reading_state_last_modified,
-            tags_last_modified=tags_last_modified
+            tags_last_modified=tags_last_modified,
+            #books_last_id=books_last_id
        )

    def set_kobo_store_header(self, store_headers):
@@ -170,7 +172,16 @@ class SyncToken:
                "books_last_created": to_epoch_timestamp(self.books_last_created),
                "archive_last_modified": to_epoch_timestamp(self.archive_last_modified),
                "reading_state_last_modified": to_epoch_timestamp(self.reading_state_last_modified),
-                "tags_last_modified": to_epoch_timestamp(self.tags_last_modified)
+                "tags_last_modified": to_epoch_timestamp(self.tags_last_modified),
+                #"books_last_id":self.books_last_id
            },
        }
        return b64encode_json(token)
+
+    def __str__(self):
+        return "{},{},{},{},{},{}".format(self.books_last_created,
+                                       self.books_last_modified,
+                                       self.archive_last_modified,
+                                       self.reading_state_last_modified,
+                                       self.tags_last_modified, self.raw_kobo_store_token)
+                                       #self.books_last_id)
@@ -16,8 +16,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
-
 from .. import logger


@@ -45,3 +43,9 @@ except ImportError as err:
    log.debug("Cannot import SyncToken, syncing books with Kobo Devices will not work: %s", err)
    kobo = None
    SyncToken = None
+
+try:
+    from . import gmail
+except ImportError as err:
+    log.debug("Cannot import gmail, sending books via Gmail Oauth2 Verification will not work: %s", err)
+    gmail = None
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2021 OzzieIsaacs
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import os.path
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+from google.oauth2.credentials import Credentials
+
+from datetime import datetime
+import base64
+from flask_babel import gettext as _
+from ..constants import BASE_DIR
+from .. import logger
+
+
+log = logger.create()
+
+SCOPES = ['openid', 'https://www.googleapis.com/auth/gmail.send', 'https://www.googleapis.com/auth/userinfo.email']
+
+def setup_gmail(token):
+    # If there are no (valid) credentials available, let the user log in.
+    creds = None
+    if "token" in token:
+        creds = Credentials(
+            token=token['token'],
+            refresh_token=token['refresh_token'],
+            token_uri=token['token_uri'],
+            client_id=token['client_id'],
+            client_secret=token['client_secret'],
+            scopes=token['scopes'],
+        )
+        creds.expiry = datetime.fromisoformat(token['expiry'])
+
+    if not creds or not creds.valid:
+        # don't forget to dump one more time after the refresh
+        # also, some file-locking routines wouldn't be needless
+        if creds and creds.expired and creds.refresh_token:
+            creds.refresh(Request())
+        else:
+            cred_file = os.path.join(BASE_DIR, 'gmail.json')
+            if not os.path.exists(cred_file):
+                raise Exception(_("Found no valid gmail.json file with OAuth information"))
+            flow = InstalledAppFlow.from_client_secrets_file(
+                os.path.join(BASE_DIR, 'gmail.json'), SCOPES)
+            creds = flow.run_local_server(port=0)
+            user_info = get_user_info(creds)
+        return {
+            'token': creds.token,
+            'refresh_token': creds.refresh_token,
+            'token_uri': creds.token_uri,
+            'client_id': creds.client_id,
+            'client_secret': creds.client_secret,
+            'scopes': creds.scopes,
+            'expiry': creds.expiry.isoformat(),
+            'email': user_info
+        }
+    return {}
+
+def get_user_info(credentials):
+    user_info_service = build(serviceName='oauth2', version='v2',credentials=credentials)
+    user_info = user_info_service.userinfo().get().execute()
+    return user_info.get('email', "")
+
+def send_messsage(token, msg):
+    log.debug("Start sending e-mail via Gmail")
+    creds = Credentials(
+        token=token['token'],
+        refresh_token=token['refresh_token'],
+        token_uri=token['token_uri'],
+        client_id=token['client_id'],
+        client_secret=token['client_secret'],
+        scopes=token['scopes'],
+    )
+    creds.expiry = datetime.fromisoformat(token['expiry'])
+    if creds and creds.expired and creds.refresh_token:
+        creds.refresh(Request())
+    service = build('gmail', 'v1', credentials=creds)
+    message_as_bytes = msg.as_bytes()  # the message should converted from string to bytes.
+    message_as_base64 = base64.urlsafe_b64encode(message_as_bytes)  # encode in base64 (printable letters coding)
+    raw = message_as_base64.decode()  # convert to something  JSON serializable
+    body = {'raw': raw}
+
+    (service.users().messages().send(userId='me', body=body).execute())
+    log.debug("E-mail send successfully via Gmail")
@@ -16,7 +16,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import time
 from functools import reduce

@@ -72,7 +71,7 @@ def get_author_info(author_name):
        author_info = _client.find_author(author_name=author_name)
    except Exception as ex:
        # Skip goodreads, if site is down/inaccessible
-        log.warning('Goodreads website is down/inaccessible? %s', ex)
+        log.warning('Goodreads website is down/inaccessible? %s', ex.__str__())
        return

    if author_info:
@@ -16,11 +16,10 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
 import base64

 from flask_simpleldap import LDAP, LDAPException
-
+from flask_simpleldap import ldap as pyLDAP
 from .. import constants, logger

 try:
@@ -38,6 +37,7 @@ def init_app(app, config):

    app.config['LDAP_HOST'] = config.config_ldap_provider_url
    app.config['LDAP_PORT'] = config.config_ldap_port
+    app.config['LDAP_CUSTOM_OPTIONS'] = {pyLDAP.OPT_REFERRALS: 0}
    if config.config_ldap_encryption == 2:
        app.config['LDAP_SCHEMA'] = 'ldaps'
    else:
@@ -54,8 +54,14 @@ def init_app(app, config):
        app.config['LDAP_USERNAME'] = ""
        app.config['LDAP_PASSWORD'] = base64.b64decode("")
    if bool(config.config_ldap_cert_path):
-        app.config['LDAP_REQUIRE_CERT'] = True
-        app.config['LDAP_CERT_PATH'] = config.config_ldap_cert_path
+        app.config['LDAP_CUSTOM_OPTIONS'].update({
+            pyLDAP.OPT_X_TLS_REQUIRE_CERT: pyLDAP.OPT_X_TLS_DEMAND,
+            pyLDAP.OPT_X_TLS_CACERTFILE: config.config_ldap_cacert_path,
+            pyLDAP.OPT_X_TLS_CERTFILE: config.config_ldap_cert_path,
+            pyLDAP.OPT_X_TLS_KEYFILE: config.config_ldap_key_path,
+            pyLDAP.OPT_X_TLS_NEWCTX: 0
+            })
+
    app.config['LDAP_BASE_DN'] = config.config_ldap_dn
    app.config['LDAP_USER_OBJECT_FILTER'] = config.config_ldap_user_object

@@ -67,12 +73,19 @@ def init_app(app, config):

    try:
        _ldap.init_app(app)
+    except ValueError:
+        if bool(config.config_ldap_cert_path):
+            app.config['LDAP_CUSTOM_OPTIONS'].pop(pyLDAP.OPT_X_TLS_NEWCTX)
+        try:
+            _ldap.init_app(app)
+        except RuntimeError as e:
+            log.error(e)
    except RuntimeError as e:
        log.error(e)


-def get_object_details(user=None, group=None, query_filter=None, dn_only=False):
-    return _ldap.get_object_details(user, group, query_filter, dn_only)
+def get_object_details(user=None,query_filter=None):
+    return _ldap.get_object_details(user, query_filter=query_filter)


 def bind():
@@ -103,7 +116,7 @@ def bind_user(username, password):
        return None, error
    except LDAPException as ex:
        if ex.message == 'Invalid credentials':
-            error = ("LDAP admin login failed")
+            error = "LDAP admin login failed"
            return None, error
        if ex.message == "Can't contact LDAP server":
            # log.warning('LDAP Server down: %s', ex)
@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+
+#  This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+#    Copyright (C) 2020 pwr
+#
+#  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
+#  (at your option) 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, see <http://www.gnu.org/licenses/>.
+
+import threading
+import abc
+import uuid
+import time
+
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+from datetime import datetime
+from collections import namedtuple
+
+from cps import logger
+
+log = logger.create()
+
+# task 'status' consts
+STAT_WAITING = 0
+STAT_FAIL = 1
+STAT_STARTED = 2
+STAT_FINISH_SUCCESS = 3
+
+# Only retain this many tasks in dequeued list
+TASK_CLEANUP_TRIGGER = 20
+
+QueuedTask = namedtuple('QueuedTask', 'num, user, added, task')
+
+
+def _get_main_thread():
+    for t in threading.enumerate():
+        if t.__class__.__name__ == '_MainThread':
+            return t
+    raise Exception("main thread not found?!")
+
+
+
+class ImprovedQueue(queue.Queue):
+    def to_list(self):
+        """
+        Returns a copy of all items in the queue without removing them.
+        """
+
+        with self.mutex:
+            return list(self.queue)
+
+# Class for all worker tasks in the background
+class WorkerThread(threading.Thread):
+    _instance = None
+
+    @classmethod
+    def getInstance(cls):
+        if cls._instance is None:
+            cls._instance = WorkerThread()
+        return cls._instance
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+
+        self.dequeued = list()
+
+        self.doLock = threading.Lock()
+        self.queue = ImprovedQueue()
+        self.num = 0
+        self.start()
+
+    @classmethod
+    def add(cls, user, task):
+        ins = cls.getInstance()
+        ins.num += 1
+        log.debug("Add Task for user: {} - {}".format(user, task))
+        ins.queue.put(QueuedTask(
+            num=ins.num,
+            user=user,
+            added=datetime.now(),
+            task=task,
+        ))
+
+    @property
+    def tasks(self):
+        with self.doLock:
+            tasks = self.queue.to_list() + self.dequeued
+            return sorted(tasks, key=lambda x: x.num)
+
+    def cleanup_tasks(self):
+        with self.doLock:
+            dead = []
+            alive = []
+            for x in self.dequeued:
+                (dead if x.task.dead else alive).append(x)
+
+            # if the ones that we need to keep are within the trigger, do nothing else
+            delta = len(self.dequeued) - len(dead)
+            if delta > TASK_CLEANUP_TRIGGER:
+                ret = alive
+            else:
+                # otherwise, lop off the oldest dead tasks until we hit the target trigger
+                ret = sorted(dead, key=lambda x: x.task.end_time)[-TASK_CLEANUP_TRIGGER:] + alive
+
+            self.dequeued = sorted(ret, key=lambda x: x.num)
+
+    # Main thread loop starting the different tasks
+    def run(self):
+        main_thread = _get_main_thread()
+        while main_thread.is_alive():
+            try:
+                # this blocks until something is available. This can cause issues when the main thread dies - this
+                # thread will remain alive. We implement a timeout to unblock every second which allows us to check if
+                # the main thread is still alive.
+                # We don't use a daemon here because we don't want the tasks to just be abruptly halted, leading to
+                # possible file / database corruption
+                item = self.queue.get(timeout=1)
+            except queue.Empty:
+                time.sleep(1)
+                continue
+
+            with self.doLock:
+                # add to list so that in-progress tasks show up
+                self.dequeued.append(item)
+
+            # once we hit our trigger, start cleaning up dead tasks
+            if len(self.dequeued) > TASK_CLEANUP_TRIGGER:
+                self.cleanup_tasks()
+
+            # sometimes tasks (like Upload) don't actually have work to do and are created as already finished
+            if item.task.stat is STAT_WAITING:
+                # CalibreTask.start() should wrap all exceptions in it's own error handling
+                item.task.start(self)
+
+            self.queue.task_done()
+
+
+class CalibreTask:
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self, message):
+        self._progress = 0
+        self.stat = STAT_WAITING
+        self.error = None
+        self.start_time = None
+        self.end_time = None
+        self.message = message
+        self.id = uuid.uuid4()
+
+    @abc.abstractmethod
+    def run(self, worker_thread):
+        """Provides the caller some human-readable name for this class"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def name(self):
+        """Provides the caller some human-readable name for this class"""
+        raise NotImplementedError
+
+    def start(self, *args):
+        self.start_time = datetime.now()
+        self.stat = STAT_STARTED
+
+        # catch any unhandled exceptions in a task and automatically fail it
+        try:
+            self.run(*args)
+        except Exception as ex:
+            self._handleError(str(ex))
+            log.debug_or_exception(ex)
+
+        self.end_time = datetime.now()
+
+    @property
+    def stat(self):
+        return self._stat
+
+    @stat.setter
+    def stat(self, x):
+        self._stat = x
+
+    @property
+    def progress(self):
+        return self._progress
+
+    @progress.setter
+    def progress(self, x):
+        if not 0 <= x <= 1:
+            raise ValueError("Task progress should within [0, 1] range")
+        self._progress = x
+
+    @property
+    def error(self):
+        return self._error
+
+    @error.setter
+    def error(self, x):
+        self._error = x
+
+    @property
+    def runtime(self):
+        return (self.end_time or datetime.now()) - self.start_time
+
+    @property
+    def dead(self):
+        """Determines whether or not this task can be garbage collected
+
+        We have a separate dictating this because there may be certain tasks that want to override this
+        """
+        # By default, we're good to clean a task if it's "Done"
+        return self.stat in (STAT_FINISH_SUCCESS, STAT_FAIL)
+
+    '''@progress.setter
+    def progress(self, x):        
+        if x > 1: 
+            x = 1
+        if x < 0: 
+            x = 0
+        self._progress = x'''
+
+    def _handleError(self, error_message):
+        self.stat = STAT_FAIL
+        self.progress = 1
+        self.error = error_message
+
+    def _handleSuccess(self):
+        self.stat = STAT_FINISH_SUCCESS
+        self.progress = 1
@@ -20,18 +20,18 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

-from __future__ import division, print_function, unicode_literals
+import sys
 from datetime import datetime

-from flask import Blueprint, request, flash, redirect, url_for
+from flask import Blueprint, flash, redirect, request, url_for
 from flask_babel import gettext as _
-from flask_login import login_required, current_user
-from sqlalchemy.sql.expression import func
-from sqlalchemy.exc import OperationalError, InvalidRequestError
-
-from . import logger, ub, searched_ids, calibre_db
-from .web import login_required_if_no_ano, render_title_template
+from flask_login import current_user, login_required
+from sqlalchemy.exc import InvalidRequestError, OperationalError
+from sqlalchemy.sql.expression import func, true

+from . import calibre_db, config, db, logger, ub
+from .render_template import render_title_template
+from .usermanagement import login_required_if_no_ano

 shelf = Blueprint('shelf', __name__)
 log = logger.create()
@@ -56,7 +56,7 @@ def check_shelf_view_permissions(cur_shelf):
    return True


-@shelf.route("/shelf/add/<int:shelf_id>/<int:book_id>")
+@shelf.route("/shelf/add/<int:shelf_id>/<int:book_id>", methods=["POST"])
@login_required
 def add_to_shelf(shelf_id, book_id):
    xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest'
@@ -70,10 +70,9 @@ def add_to_shelf(shelf_id, book_id):

    if not check_shelf_edit_permissions(shelf):
        if not xhr:
-            flash(_(u"Sorry you are not allowed to add a book to the the shelf: %(shelfname)s", shelfname=shelf.name),
-                  category="error")
+            flash(_(u"Sorry you are not allowed to add a book to that shelf"), category="error")
            return redirect(url_for('web.index'))
-        return "Sorry you are not allowed to add a book to the the shelf: %s" % shelf.name, 403
+        return "Sorry you are not allowed to add a book to the that shelf", 403

    book_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id,
                                                          ub.BookShelf.book_id == book_id).first()
@@ -97,12 +96,14 @@ def add_to_shelf(shelf_id, book_id):
        ub.session.commit()
    except (OperationalError, InvalidRequestError):
        ub.session.rollback()
+        log.error("Settings DB is not Writeable")
        flash(_(u"Settings DB is not Writeable"), category="error")
        if "HTTP_REFERER" in request.environ:
            return redirect(request.environ["HTTP_REFERER"])
        else:
            return redirect(url_for('web.index'))
    if not xhr:
+        log.debug("Book has been added to shelf: {}".format(shelf.name))
        flash(_(u"Book has been added to shelf: %(sname)s", sname=shelf.name), category="success")
        if "HTTP_REFERER" in request.environ:
            return redirect(request.environ["HTTP_REFERER"])
@@ -111,7 +112,7 @@ def add_to_shelf(shelf_id, book_id):
    return "", 204


-@shelf.route("/shelf/massadd/<int:shelf_id>")
+@shelf.route("/shelf/massadd/<int:shelf_id>", methods=["POST"])
@login_required
 def search_to_shelf(shelf_id):
    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
@@ -121,35 +122,32 @@ def search_to_shelf(shelf_id):
        return redirect(url_for('web.index'))

    if not check_shelf_edit_permissions(shelf):
-        flash(_(u"You are not allowed to add a book to the the shelf: %(name)s", name=shelf.name), category="error")
+        log.warning("You are not allowed to add a book to the shelf".format(shelf.name))
+        flash(_(u"You are not allowed to add a book to the shelf"), category="error")
        return redirect(url_for('web.index'))

-    if current_user.id in searched_ids and searched_ids[current_user.id]:
+    if current_user.id in ub.searched_ids and ub.searched_ids[current_user.id]:
        books_for_shelf = list()
        books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).all()
        if books_in_shelf:
            book_ids = list()
            for book_id in books_in_shelf:
                book_ids.append(book_id.book_id)
-            for searchid in searched_ids[current_user.id]:
+            for searchid in ub.searched_ids[current_user.id]:
                if searchid not in book_ids:
                    books_for_shelf.append(searchid)
        else:
-            books_for_shelf = searched_ids[current_user.id]
+            books_for_shelf = ub.searched_ids[current_user.id]

        if not books_for_shelf:
-            log.error("Books are already part of %s", shelf)
+            log.error("Books are already part of {}".format(shelf.name))
            flash(_(u"Books are already part of the shelf: %(name)s", name=shelf.name), category="error")
            return redirect(url_for('web.index'))

-        maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()
-        if maxOrder[0] is None:
-            maxOrder = 0
-        else:
-            maxOrder = maxOrder[0]
+        maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()[0] or 0

        for book in books_for_shelf:
-            maxOrder = maxOrder + 1
+            maxOrder += 1
            shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book, order=maxOrder))
        shelf.last_modified = datetime.utcnow()
        try:
@@ -158,19 +156,21 @@ def search_to_shelf(shelf_id):
            flash(_(u"Books have been added to shelf: %(sname)s", sname=shelf.name), category="success")
        except (OperationalError, InvalidRequestError):
            ub.session.rollback()
-            flash(_(u"Settings DB is not Writeable"), category="error")
+            log.error("Settings DB is not Writeable")
+            flash(_("Settings DB is not Writeable"), category="error")
    else:
+        log.error("Could not add books to shelf: {}".format(shelf.name))
        flash(_(u"Could not add books to shelf: %(sname)s", sname=shelf.name), category="error")
    return redirect(url_for('web.index'))


-@shelf.route("/shelf/remove/<int:shelf_id>/<int:book_id>")
+@shelf.route("/shelf/remove/<int:shelf_id>/<int:book_id>", methods=["POST"])
@login_required
 def remove_from_shelf(shelf_id, book_id):
    xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest'
    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
    if shelf is None:
-        log.error("Invalid shelf specified: %s", shelf_id)
+        log.error("Invalid shelf specified: {}".format(shelf_id))
        if not xhr:
            return redirect(url_for('web.index'))
        return "Invalid shelf specified", 400
@@ -199,7 +199,8 @@ def remove_from_shelf(shelf_id, book_id):
            ub.session.commit()
        except (OperationalError, InvalidRequestError):
            ub.session.rollback()
-            flash(_(u"Settings DB is not Writeable"), category="error")
+            log.error("Settings DB is not Writeable")
+            flash(_("Settings DB is not Writeable"), category="error")
            if "HTTP_REFERER" in request.environ:
                return redirect(request.environ["HTTP_REFERER"])
            else:
@@ -213,106 +214,108 @@ def remove_from_shelf(shelf_id, book_id):
        return "", 204
    else:
        if not xhr:
-            flash(_(u"Sorry you are not allowed to remove a book from this shelf: %(sname)s", sname=shelf.name),
+            log.warning("You are not allowed to remove a book from shelf: {}".format(shelf.name))
+            flash(_(u"Sorry you are not allowed to remove a book from this shelf"),
                  category="error")
            return redirect(url_for('web.index'))
-        return "Sorry you are not allowed to remove a book from this shelf: %s" % shelf.name, 403
+        return "Sorry you are not allowed to remove a book from this shelf", 403


@shelf.route("/shelf/create", methods=["GET", "POST"])
@login_required
 def create_shelf():
    shelf = ub.Shelf()
-    if request.method == "POST":
-        to_save = request.form.to_dict()
-        if "is_public" in to_save:
-            shelf.is_public = 1
-        shelf.name = to_save["title"]
-        shelf.user_id = int(current_user.id)
+    return create_edit_shelf(shelf, page_title=_(u"Create a Shelf"), page="shelfcreate")

-        is_shelf_name_unique = False
-        if shelf.is_public == 1:
-            is_shelf_name_unique = ub.session.query(ub.Shelf) \
-                .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \
-                .first() is None
-
-            if not is_shelf_name_unique:
-                flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]),
-                      category="error")
-        else:
-            is_shelf_name_unique = ub.session.query(ub.Shelf) \
-                .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) &
-                        (ub.Shelf.user_id == int(current_user.id)))\
-                                       .first() is None
-
-            if not is_shelf_name_unique:
-                flash(_(u"A private shelf with the name '%(title)s' already exists.", title=to_save["title"]),
-                      category="error")
-
-        if is_shelf_name_unique:
-            try:
-                ub.session.add(shelf)
-                ub.session.commit()
-                flash(_(u"Shelf %(title)s created", title=to_save["title"]), category="success")
-                return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id))
-            except (OperationalError, InvalidRequestError):
-                ub.session.rollback()
-                flash(_(u"Settings DB is not Writeable"), category="error")
-            except Exception:
-                ub.session.rollback()
-                flash(_(u"There was an error"), category="error")
-        return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Create a Shelf"), page="shelfcreate")
-    else:
-        return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Create a Shelf"), page="shelfcreate")


@shelf.route("/shelf/edit/<int:shelf_id>", methods=["GET", "POST"])
@login_required
 def edit_shelf(shelf_id):
    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
+    if not check_shelf_edit_permissions(shelf):
+        flash(_(u"Sorry you are not allowed to edit this shelf"), category="error")
+        return redirect(url_for('web.index'))
+    return create_edit_shelf(shelf, page_title=_(u"Edit a shelf"), page="shelfedit", shelf_id=shelf_id)
+
+
+# if shelf ID is set, we are editing a shelf
+def create_edit_shelf(shelf, page_title, page, shelf_id=False):
+    sync_only_selected_shelves = current_user.kobo_only_shelves_sync
+    # calibre_db.session.query(ub.Shelf).filter(ub.Shelf.user_id == current_user.id).filter(ub.Shelf.kobo_sync).count()
    if request.method == "POST":
        to_save = request.form.to_dict()
-
-        is_shelf_name_unique = False
-        if shelf.is_public == 1:
-            is_shelf_name_unique = ub.session.query(ub.Shelf) \
-                .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \
-                .filter(ub.Shelf.id != shelf_id) \
-                .first() is None
-
-            if not is_shelf_name_unique:
-                flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]),
-                      category="error")
-        else:
-            is_shelf_name_unique = ub.session.query(ub.Shelf) \
-                .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) &
-                        (ub.Shelf.user_id == int(current_user.id)))\
-                                       .filter(ub.Shelf.id != shelf_id)\
-                                       .first() is None
-
-            if not is_shelf_name_unique:
-                flash(_(u"A private shelf with the name '%(title)s' already exists.", title=to_save["title"]),
-                      category="error")
-
-        if is_shelf_name_unique:
-            shelf.name = to_save["title"]
-            shelf.last_modified = datetime.utcnow()
-            if "is_public" in to_save:
-                shelf.is_public = 1
+        if not current_user.role_edit_shelfs() and to_save.get("is_public") == "on":
+            flash(_(u"Sorry you are not allowed to create a public shelf"), category="error")
+            return redirect(url_for('web.index'))
+        is_public = 1 if to_save.get("is_public") == "on" else 0
+        if config.config_kobo_sync:
+            shelf.kobo_sync = True if to_save.get("kobo_sync") else False
+            if shelf.kobo_sync:
+                ub.session.query(ub.ShelfArchive).filter(ub.ShelfArchive.user_id == current_user.id).filter(
+                    ub.ShelfArchive.uuid == shelf.uuid).delete()
+                ub.session_commit()
+        shelf_title = to_save.get("title", "")
+        if check_shelf_is_unique(shelf, shelf_title, is_public, shelf_id):
+            shelf.name = shelf_title
+            shelf.is_public = is_public
+            if not shelf_id:
+                shelf.user_id = int(current_user.id)
+                ub.session.add(shelf)
+                shelf_action = "created"
+                flash_text = _(u"Shelf %(title)s created", title=shelf_title)
            else:
-                shelf.is_public = 0
+                shelf_action = "changed"
+                flash_text = _(u"Shelf %(title)s changed", title=shelf_title)
            try:
                ub.session.commit()
-                flash(_(u"Shelf %(title)s changed", title=to_save["title"]), category="success")
-            except (OperationalError, InvalidRequestError):
+                log.info(u"Shelf {} {}".format(shelf_title, shelf_action))
+                flash(flash_text, category="success")
+                return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id))
+            except (OperationalError, InvalidRequestError) as ex:
                ub.session.rollback()
-                flash(_(u"Settings DB is not Writeable"), category="error")
-            except Exception:
+                log.debug_or_exception(ex)
+                log.error("Settings DB is not Writeable")
+                flash(_("Settings DB is not Writeable"), category="error")
+            except Exception as ex:
                ub.session.rollback()
+                log.debug_or_exception(ex)
                flash(_(u"There was an error"), category="error")
-        return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"), page="shelfedit")
+    return render_title_template('shelf_edit.html',
+                                 shelf=shelf,
+                                 title=page_title,
+                                 page=page,
+                                 kobo_sync_enabled=config.config_kobo_sync,
+                                 sync_only_selected_shelves=sync_only_selected_shelves)
+
+
+def check_shelf_is_unique(shelf, title, is_public, shelf_id=False):
+    if shelf_id:
+        ident = ub.Shelf.id != shelf_id
    else:
-        return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"), page="shelfedit")
+        ident = true()
+    if is_public == 1:
+        is_shelf_name_unique = ub.session.query(ub.Shelf) \
+                                   .filter((ub.Shelf.name == title) & (ub.Shelf.is_public == 1)) \
+                                   .filter(ident) \
+                                   .first() is None
+
+        if not is_shelf_name_unique:
+            log.error("A public shelf with the name '{}' already exists.".format(title))
+            flash(_(u"A public shelf with the name '%(title)s' already exists.", title=title),
+                  category="error")
+    else:
+        is_shelf_name_unique = ub.session.query(ub.Shelf) \
+                                   .filter((ub.Shelf.name == title) & (ub.Shelf.is_public == 0) &
+                                           (ub.Shelf.user_id == int(current_user.id))) \
+                                   .filter(ident) \
+                                   .first() is None
+
+        if not is_shelf_name_unique:
+            log.error("A private shelf with the name '{}' already exists.".format(title))
+            flash(_(u"A private shelf with the name '%(title)s' already exists.", title=title),
+                  category="error")
+    return is_shelf_name_unique


 def delete_shelf_helper(cur_shelf):
@@ -322,55 +325,35 @@ def delete_shelf_helper(cur_shelf):
    ub.session.delete(cur_shelf)
    ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).delete()
    ub.session.add(ub.ShelfArchive(uuid=cur_shelf.uuid, user_id=cur_shelf.user_id))
-    ub.session.commit()
-    log.info("successfully deleted %s", cur_shelf)
+    ub.session_commit("successfully deleted Shelf {}".format(cur_shelf.name))


-
-@shelf.route("/shelf/delete/<int:shelf_id>")
+@shelf.route("/shelf/delete/<int:shelf_id>", methods=["POST"])
@login_required
 def delete_shelf(shelf_id):
    cur_shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
    try:
        delete_shelf_helper(cur_shelf)
-    except (OperationalError, InvalidRequestError):
+        flash(_("Shelf successfully deleted"), category="success")
+    except InvalidRequestError:
        ub.session.rollback()
-        flash(_(u"Settings DB is not Writeable"), category="error")
+        log.error("Settings DB is not Writeable")
+        flash(_("Settings DB is not Writeable"), category="error")
    return redirect(url_for('web.index'))


-@shelf.route("/shelf/<int:shelf_id>", defaults={'shelf_type': 1})
-@shelf.route("/shelf/<int:shelf_id>/<int:shelf_type>")
+@shelf.route("/simpleshelf/<int:shelf_id>")
@login_required_if_no_ano
-def show_shelf(shelf_type, shelf_id):
-    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
+def show_simpleshelf(shelf_id):
+    return render_show_shelf(2, shelf_id, 1, None)

-    result = list()
-    # user is allowed to access shelf
-    if shelf and check_shelf_view_permissions(shelf):
-        page = "shelf.html" if shelf_type == 1 else 'shelfdown.html'

-        books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id)\
-            .order_by(ub.BookShelf.order.asc()).all()
-        for book in books_in_shelf:
-            cur_book = calibre_db.get_filtered_book(book.book_id)
-            if cur_book:
-                result.append(cur_book)
-            else:
-                cur_book = calibre_db.get_book(book.book_id)
-                if not cur_book:
-                    log.info('Not existing book %s in %s deleted', book.book_id, shelf)
-                    try:
-                        ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == book.book_id).delete()
-                        ub.session.commit()
-                    except (OperationalError, InvalidRequestError):
-                        ub.session.rollback()
-                        flash(_(u"Settings DB is not Writeable"), category="error")
-        return render_title_template(page, entries=result, title=_(u"Shelf: '%(name)s'", name=shelf.name),
-                                     shelf=shelf, page="shelf")
-    else:
-        flash(_(u"Error opening shelf. Shelf does not exist or is not accessible"), category="error")
-        return redirect(url_for("web.index"))
+@shelf.route("/shelf/<int:shelf_id>", defaults={"sort_param": "order", 'page': 1})
+@shelf.route("/shelf/<int:shelf_id>/<sort_param>", defaults={'page': 1})
+@shelf.route("/shelf/<int:shelf_id>/<sort_param>/<int:page>")
+@login_required_if_no_ano
+def show_shelf(shelf_id, sort_param, page):
+    return render_show_shelf(1, shelf_id, page, sort_param)


@shelf.route("/shelf/order/<int:shelf_id>", methods=["GET", "POST"])
@@ -389,27 +372,90 @@ def order_shelf(shelf_id):
            ub.session.commit()
        except (OperationalError, InvalidRequestError):
            ub.session.rollback()
-            flash(_(u"Settings DB is not Writeable"), category="error")
+            log.error("Settings DB is not Writeable")
+            flash(_("Settings DB is not Writeable"), category="error")

    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
    result = list()
    if shelf and check_shelf_view_permissions(shelf):
-        books_in_shelf2 = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \
-            .order_by(ub.BookShelf.order.asc()).all()
-        for book in books_in_shelf2:
-            cur_book = calibre_db.get_filtered_book(book.book_id)
-            if cur_book:
-                result.append({'title': cur_book.title,
-                               'id': cur_book.id,
-                               'author': cur_book.authors,
-                               'series': cur_book.series,
-                               'series_index': cur_book.series_index})
-            else:
-                cur_book = calibre_db.get_book(book.book_id)
-                result.append({'title': _('Hidden Book'),
-                               'id': cur_book.id,
-                               'author': [],
-                               'series': []})
+        result = calibre_db.session.query(db.Books) \
+            .join(ub.BookShelf, ub.BookShelf.book_id == db.Books.id, isouter=True) \
+            .add_columns(calibre_db.common_filters().label("visible")) \
+            .filter(ub.BookShelf.shelf == shelf_id).order_by(ub.BookShelf.order.asc()).all()
    return render_title_template('shelf_order.html', entries=result,
                                 title=_(u"Change order of Shelf: '%(name)s'", name=shelf.name),
                                 shelf=shelf, page="shelforder")
+
+
+def change_shelf_order(shelf_id, order):
+    result = calibre_db.session.query(db.Books).outerjoin(db.books_series_link,
+                                                          db.Books.id == db.books_series_link.c.book)\
+        .outerjoin(db.Series).join(ub.BookShelf, ub.BookShelf.book_id == db.Books.id) \
+        .filter(ub.BookShelf.shelf == shelf_id).order_by(*order).all()
+    for index, entry in enumerate(result):
+        book = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \
+            .filter(ub.BookShelf.book_id == entry.id).first()
+        book.order = index
+    ub.session_commit("Shelf-id:{} - Order changed".format(shelf_id))
+
+
+def render_show_shelf(shelf_type, shelf_id, page_no, sort_param):
+    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
+
+    # check user is allowed to access shelf
+    if shelf and check_shelf_view_permissions(shelf):
+
+        if shelf_type == 1:
+            # order = [ub.BookShelf.order.asc()]
+            if sort_param == 'pubnew':
+                change_shelf_order(shelf_id, [db.Books.pubdate.desc()])
+            if sort_param == 'pubold':
+                change_shelf_order(shelf_id, [db.Books.pubdate])
+            if sort_param == 'abc':
+                change_shelf_order(shelf_id, [db.Books.sort])
+            if sort_param == 'zyx':
+                change_shelf_order(shelf_id, [db.Books.sort.desc()])
+            if sort_param == 'new':
+                change_shelf_order(shelf_id, [db.Books.timestamp.desc()])
+            if sort_param == 'old':
+                change_shelf_order(shelf_id, [db.Books.timestamp])
+            if sort_param == 'authaz':
+                change_shelf_order(shelf_id, [db.Books.author_sort.asc(), db.Series.name, db.Books.series_index])
+            if sort_param == 'authza':
+                change_shelf_order(shelf_id, [db.Books.author_sort.desc(),
+                                              db.Series.name.desc(),
+                                              db.Books.series_index.desc()])
+            page = "shelf.html"
+            pagesize = 0
+        else:
+            pagesize = sys.maxsize
+            page = 'shelfdown.html'
+
+        result, __, pagination = calibre_db.fill_indexpage(page_no, pagesize,
+                                                           db.Books,
+                                                           ub.BookShelf.shelf == shelf_id,
+                                                           [ub.BookShelf.order.asc()],
+                                                           ub.BookShelf, ub.BookShelf.book_id == db.Books.id)
+        # delete chelf entries where book is not existent anymore, can happen if book is deleted outside calibre-web
+        wrong_entries = calibre_db.session.query(ub.BookShelf) \
+            .join(db.Books, ub.BookShelf.book_id == db.Books.id, isouter=True) \
+            .filter(db.Books.id == None).all()
+        for entry in wrong_entries:
+            log.info('Not existing book {} in {} deleted'.format(entry.book_id, shelf))
+            try:
+                ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == entry.book_id).delete()
+                ub.session.commit()
+            except (OperationalError, InvalidRequestError):
+                ub.session.rollback()
+                log.error("Settings DB is not Writeable")
+                flash(_("Settings DB is not Writeable"), category="error")
+
+        return render_title_template(page,
+                                     entries=result,
+                                     pagination=pagination,
+                                     title=_(u"Shelf: '%(name)s'", name=shelf.name),
+                                     shelf=shelf,
+                                     page="shelf")
+    else:
+        flash(_(u"Error opening shelf. Shelf does not exist or is not accessible"), category="error")
+        return redirect(url_for("web.index"))
--- a/Show More
+++ b/Show More