Added translations

Update Teststatus
Update Version
2021-02-02 19:04:55 +01:00 · 2021-02-02 18:52:31 +01:00 · 2021-02-01 19:00:10 +01:00 · 2021-01-31 19:20:43 +01:00 · 2021-01-31 19:01:34 +01:00 · 2021-01-31 11:21:09 +01:00
224 changed files with 54567 additions and 25158 deletions
@@ -6,6 +6,7 @@ labels: ''
 assignees: ''

 ---
+<!-- Please have a look at our [Contributing Guidelines](https://github.com/janeczku/calibre-web/blob/master/CONTRIBUTING.md) -->

 **Describe the bug/problem**
 A clear and concise description of what the bug is. If you are asking for support, please check our [Wiki](https://github.com/janeczku/calibre-web/wiki) if your question is already answered there.
@@ -27,12 +28,12 @@ A clear and concise description of what you expected to happen.
 If applicable, add screenshots to help explain your problem.

 **Environment (please complete the following information):**
- - OS: [e.g. Windows 10/raspian]
- - Python version [e.g. python2.7]
- - Calibre-Web version [e.g. 0.6.5 or master@16.02.20, 19:55 ]:
- - Docker container [ None/Technosoft2000/Linuxuser]:
- - Special Hardware [e.g. Rasperry Pi Zero]
- - Browser [e.g. chrome, safari]
+ - 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/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]

 **Additional context**
-Add any other context about the problem here. [e.g. access via reverse proxy]
+Add any other context about the problem here. [e.g. access via reverse proxy, database background sync, special database location]
@@ -7,6 +7,8 @@ assignees: ''

 ---

+<!-- Please have a look at our [Contributing Guidelines](https://github.com/janeczku/calibre-web/blob/master/CONTRIBUTING.md) -->
+
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

@@ -1,49 +1,46 @@
 ## How to contribute to Calibre-Web

-First of all, we would like to thank you for reading this text. we are happy you are willing to contribute to Calibre-Web
+First of all, we would like to thank you for reading this text. We are happy you are willing to contribute to Calibre-Web.

 ### **General**

-**Communication language** is english. Google translated texts are not as bad as you might think, they are usually understandable, so don't worry if you generate your post that way.
+**Communication language** is English. Google translated texts are not as bad as you might think, they are usually understandable, so don't worry if you generate your post that way.

 **Calibre-Web** is not **Calibre**. If you are having a question regarding Calibre please post this at their [repository](https://github.com/kovidgoyal/calibre).

-**Docker-Containers** of Calibre-Web are maintained by different persons than the people who drive Calibre-Web. If we come to the conclusion during our analysis that the problem is related to Docker, we might ask you to open a new issue at the reprository of the Docker Container.
+**Docker-Containers** of Calibre-Web are maintained by different persons than the people who drive Calibre-Web. If we come to the conclusion during our analysis that the problem is related to Docker, we might ask you to open a new issue at the repository of the Docker Container.

-If you are having **Basic Installation Problems** with python or it's dependencies, please consider using your favorite search engine to find a solution. In case you can't find a solution, we are happy to help you.
+If you are having **Basic Installation Problems** with python or its dependencies, please consider using your favorite search engine to find a solution. In case you can't find a solution, we are happy to help you.

-We can offer only very limited support regarding configuration of **Reverse-Proxy Installations**, **OPDS-Reader** or other programs in combination with Calibre-Web. 
+We can offer only very limited support regarding configuration of **Reverse-Proxy Installations**, **OPDS-Reader** or other programs in combination with Calibre-Web.

 ### **Translation**

-Some of the user languages in Calibre-Web having missing translations. We are happy to add the missing texts if you are translate them. Create a Pull Request, create an issue with the .po file attached, or write an email to "ozzie.fernandez.isaacs@googlemail.com" with attached translation file. To display all book languages in your native language an additional file is used (iso_language_names.py). The content of this file is autogenerated with the corresponding translations of Calibre, please do not edit this file on your own. 
+Some of the user languages in Calibre-Web having missing translations. We are happy to add the missing texts if you translate them. Create a Pull Request, create an issue with the .po file attached, or write an email to "ozzie.fernandez.isaacs@googlemail.com" with attached translation file. To display all book languages in your native language an additional file is used (iso_language_names.py). The content of this file is auto-generated with the corresponding translations of Calibre, please do not edit this file on your own.

 ### **Documentation**

-The Calibre-Web documentation is hosted in the Github [Wiki](https://github.com/janeczku/calibre-web/wiki). The Wiki is open to everybody, if you find a problem, feel free to correct it. If information is missing, you are welcome to add it. The content will be reviewed time by time. Please try to be consitent with the form with the other Wiki pages (e.g. the project name is Calibre-Web with 2 capital letters and a dash in between).
+The Calibre-Web documentation is hosted in the Github [Wiki](https://github.com/janeczku/calibre-web/wiki). The Wiki is open to everybody, if you find a problem, feel free to correct it. If information is missing, you are welcome to add it. The content will be reviewed time by time. Please try to be consistent with the form with the other Wiki pages (e.g. the project name is Calibre-Web with 2 capital letters and a dash in between).

 ### **Reporting a bug**

-Do not open up a GitHub issue if the bug is a **security vulnerability** in Calibre-Web. Please write intead an email to "ozzie.fernandez.isaacs@googlemail.com".
+Do not open up a GitHub issue if the bug is a **security vulnerability** in Calibre-Web. Instead, please write an email to "ozzie.fernandez.isaacs@googlemail.com".

 Ensure the ***bug was not already reported** by searching on GitHub under [Issues](https://github.com/janeczku/calibre-web/issues). Please also check if a solution for your problem can be found in the [wiki](https://github.com/janeczku/calibre-web/wiki).

-If you're unable to find an **open issue** addressing the problem, open a [new one](https://github.com/janeczku/calibre-web/issues/new?assignees=&labels=&template=bug_report.md&title=). Be sure to include a **title** and **clear description**, as much relevant information as possible, the **issue form** helps you providing the right information. Deleting the form and just pasting the stack trace doesn't speed up fixing the problem. If your issue could be resolved, consider closing the issue. 
+If you're unable to find an **open issue** addressing the problem, open a [new one](https://github.com/janeczku/calibre-web/issues/new?assignees=&labels=&template=bug_report.md&title=). Be sure to include a **title** and **clear description**, as much relevant information as possible, the **issue form** helps you providing the right information. Deleting the form and just pasting the stack trace doesn't speed up fixing the problem. If your issue could be resolved, consider closing the issue.

 ### **Feature Request**

-If there is afeature missing in Calibre-Web and you can't find a feature request in the [Issues](https://github.com/janeczku/calibre-web/issues) section, you could create a [feature request](https://github.com/janeczku/calibre-web/issues/new?assignees=&labels=&template=feature_request.md&title=). 
-We will not extend Calibre-Web with any more login abilitys or add further files storages, or file syncing ability. Furthermore Calibre-Web is made for home usage for company inhouse usage, so requests regarding any sorts of social interaction capability, payment routines, search engine or web site analytics integration will not be implemeted. 
+If there is a feature missing in Calibre-Web and you can't find a feature request in the [Issues](https://github.com/janeczku/calibre-web/issues) section, you could create a [feature request](https://github.com/janeczku/calibre-web/issues/new?assignees=&labels=&template=feature_request.md&title=).
+We will not extend Calibre-Web with any more login abilities or add further files storages, or file syncing ability. Furthermore Calibre-Web is made for home usage for company in-house usage, so requests regarding any sorts of social interaction capability, payment routines, search engine or web site analytics integration will not be implemented.

 ### **Contributing code to Calibre-Web**

 Open a new GitHub pull request with the patch. Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.

-In case your code enhances features of Calibre-Web: Create your pull request for the development branch if your enhancement consits 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 [seperate repo](https://github.com/OzzieIsaacs/calibre-web-test) on Github. It uses unittest and performs real system tests with selenium, 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. 
-
-
+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.
+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.
@@ -12,7 +12,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 czech, dutch, english, finnish, french, german, greek, hungarian, italian, japanese, khmer, polish, russian, simplified 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)
@@ -32,8 +32,8 @@ Calibre-Web is a web app providing a clean interface for browsing, reading and d

 ## 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)
+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)
 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)
@@ -48,29 +48,27 @@ Please note that running the above install command can fail on some versions of

 ## Requirements

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

 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.

-\*** DEPRECATED \*** Support will be removed in future releases
-
-[Download](http://www.amazon.com/gp/feature.html?docId=1000765211) Amazon's KindleGen tool for your platform and place the binary named `kindlegen` in the `vendor` folder.
+[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/)
+ 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`

 #### **LinuxServer - x64, armhf, aarch64**
-+ Docker Hub - [https://hub.docker.com/r/linuxserver/calibre-web/](https://hub.docker.com/r/linuxserver/calibre-web/)
+ Docker Hub - [https://hub.docker.com/r/linuxserver/calibre-web](https://hub.docker.com/r/linuxserver/calibre-web)
 + Github - [https://github.com/linuxserver/docker-calibre-web](https://github.com/linuxserver/docker-calibre-web)
 + Github - (Optional Calibre layer) - [https://github.com/linuxserver/docker-calibre-web/tree/calibre](https://github.com/linuxserver/docker-calibre-web/tree/calibre) 

@@ -85,3 +83,7 @@ Pre-built Docker images are available in these Docker Hub repositories:
 # Wiki

 For further information, How To's and FAQ please check the [Wiki](https://github.com/janeczku/calibre-web/wiki)
+
+# Contributing to Calibre-Web
+
+Please have a look at our [Contributing Guidelines](https://github.com/janeczku/calibre-web/blob/master/CONTRIBUTING.md) 
@@ -41,6 +41,8 @@ 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.error_handler import init_errorhandler

 try:
    from cps.kobo import kobo, get_kobo_activated
@@ -58,12 +60,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)
+    # if config.config_use_google_drive:
    app.register_blueprint(gdrive)
    app.register_blueprint(editbook)
    if kobo_available:
@@ -37,6 +37,7 @@ from . import config_sql, logger, cache_buster, cli, ub, db
 from .reverseproxy import ReverseProxied
 from .server import WebServer

+
 mimetypes.init()
 mimetypes.add_type('application/xhtml+xml', '.xhtml')
 mimetypes.add_type('application/epub+zip', '.epub')
@@ -44,6 +45,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')
@@ -56,16 +58,22 @@ mimetypes.add_type('application/ogg', '.ogg')
 mimetypes.add_type('application/ogg', '.oga')

 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
+)
+

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

 ub.init_db(cli.settingspath)
 # pylint: disable=no-member
 config = config_sql.load_configuration(ub.session)

-searched_ids = {}
 web_server = WebServer()

 babel = Babel()
@@ -75,23 +83,30 @@ log = logger.create()

 from . import services

+db.CalibreDB.setup_db(config, 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')
+        app.instance_path = app.instance_path.decode('utf-8')

-    cache_buster.init_cache_busting(app)
+    if os.environ.get('FLASK_DEBUG'):
+    	cache_buster.init_cache_busting(app)

    log.info('Starting Calibre Web...')
+    if sys.version_info < (3, 0):
+        log.info('Python2 is EOL since end of 2019, this version of Calibre-Web supporting Python2 please consider upgrading to Python3')
+        print('Python2 is EOL since end of 2019, this version of Calibre-Web supporting Python2 please consider upgrading to Python3')
    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)
-    db.setup_db(config)

    babel.init_app(app)
    _BABEL_TRANSLATIONS.update(str(item) for item in babel.list_translations())
@@ -30,8 +30,8 @@ import babel, pytz, requests, sqlalchemy
 import werkzeug, flask, flask_login, flask_principal, jinja2
 from flask_babel import gettext as _

-from . import db, converter, uploader, server, isoLanguages, constants
-from .web import render_title_template
+from . import db, calibre_db, converter, uploader, server, isoLanguages, constants
+from .render_template import render_title_template
 try:
    from flask_login import __version__ as flask_loginVersion
 except ImportError:
@@ -82,13 +82,20 @@ _VERSIONS = OrderedDict(
 _VERSIONS.update(uploader.get_versions())


+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
 def stats():
-    counter = db.session.query(db.Books).count()
-    authors = db.session.query(db.Authors).count()
-    categorys = db.session.query(db.Tags).count()
-    series = db.session.query(db.Series).count()
-    _VERSIONS['ebook converter'] = _(converter.get_version())
-    return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, versions=_VERSIONS,
+    counter = calibre_db.session.query(db.Books).count()
+    authors = calibre_db.session.query(db.Authors).count()
+    categorys = calibre_db.session.query(db.Tags).count()
+    series = calibre_db.session.query(db.Series).count()
+    return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, versions=collect_stats(),
                                 categorycounter=categorys, seriecounter=series, title=_(u"Statistics"), page="stat")
+
+
@@ -45,6 +45,7 @@ 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='Enables filepicker in unconfigured mode')
 args = parser.parse_args()

 if sys.version_info < (3, 0):
@@ -109,4 +110,10 @@ if ipadress:
        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)
+
+# Handles enableing of filepicker
+filepicker = args.f or None
@@ -26,31 +26,64 @@ from .constants import BookMeta
 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
-except ImportError as e:
-    log.debug('cannot import comicapi, extracting comic metadata will not work: %s', e)
+    try:
+        from comicapi import __version__ as comic_version
+    except ImportError:
+        comic_version = ''
+except (ImportError, LookupError) as e:
+    log.debug('Cannot import comicapi, extracting comic metadata will not work: %s', e)
    import zipfile
    import tarfile
    try:
        import rarfile
        use_rarfile = True
-    except ImportError as e:
-        log.debug('cannot import rarfile, extracting cover files from rar files will not work: %s', 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 _extractCover(tmp_file_name, original_file_extension, rarExceutable):
+def _cover_processing(tmp_file_name, img, extension):
+    tmp_cover_name = os.path.join(os.path.dirname(tmp_file_name), 'cover.jpg')
+    if use_IM:
+        # convert to jpg because calibre only supports jpg
+        if extension in NO_JPEG_EXTENSIONS:
+            with Image(filename=tmp_file_name) as imgc:
+                imgc.format = 'jpeg'
+                imgc.transform_colorspace('rgb')
+                imgc.save(tmp_cover_name)
+                return tmp_cover_name
+
+    if not img:
+        return None
+
+    with open(tmp_cover_name, 'wb') as f:
+        f.write(img)
+    return tmp_cover_name
+
+
+
+def _extractCover(tmp_file_name, original_file_extension, rarExecutable):
    cover_data = extension = None
    if use_comic_meta:
-        archive = ComicArchive(tmp_file_name)
+        archive = ComicArchive(tmp_file_name, rar_exe_path=rarExecutable)
        for index, name in enumerate(archive.getPageNameList()):
            ext = os.path.splitext(name)
            if len(ext) > 1:
                extension = ext[1].lower()
-                if extension == '.jpg' or extension == '.jpeg':
+                if extension in COVER_EXTENSIONS:
                    cover_data = archive.getPage(index)
                    break
    else:
@@ -60,7 +93,7 @@ def _extractCover(tmp_file_name, original_file_extension, rarExceutable):
                ext = os.path.splitext(name)
                if len(ext) > 1:
                    extension = ext[1].lower()
-                    if extension == '.jpg' or extension == '.jpeg':
+                    if extension in COVER_EXTENSIONS:
                        cover_data = cf.read(name)
                        break
        elif original_file_extension.upper() == '.CBT':
@@ -69,37 +102,28 @@ def _extractCover(tmp_file_name, original_file_extension, rarExceutable):
                ext = os.path.splitext(name)
                if len(ext) > 1:
                    extension = ext[1].lower()
-                    if extension == '.jpg' or extension == '.jpeg':
+                    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 = rarExceutable
+                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 == '.jpg' or extension == '.jpeg':
+                        if extension in COVER_EXTENSIONS:
                            cover_data = cf.read(name)
                            break
            except Exception as e:
                log.debug('Rarfile failed with error: %s', e)
-
-    prefix = os.path.dirname(tmp_file_name)
-    if cover_data:
-        tmp_cover_name = prefix + '/cover' + extension
-        image = open(tmp_cover_name, 'wb')
-        image.write(cover_data)
-        image.close()
-    else:
-        tmp_cover_name = None
-    return tmp_cover_name
+    return _cover_processing(tmp_file_name, cover_data, extension)


-def get_comic_info(tmp_file_path, original_file_name, original_file_extension, rarExceutable):
+def get_comic_info(tmp_file_path, original_file_name, original_file_extension, rarExecutable):
    if use_comic_meta:
-        archive = ComicArchive(tmp_file_path, rar_exe_path=rarExceutable)
+        archive = ComicArchive(tmp_file_path, rar_exe_path=rarExecutable)
        if archive.seemsToBeAComicArchive():
            if archive.hasMetadata(MetaDataStyle.CIX):
                style = MetaDataStyle.CIX
@@ -111,21 +135,15 @@ def get_comic_info(tmp_file_path, original_file_name, original_file_extension, r
            # if style is not None:
            loadedMetadata = archive.readMetadata(style)

-            lang = loadedMetadata.language
-            if lang:
-                if len(lang) == 2:
-                     loadedMetadata.language = isoLanguages.get(part1=lang).name
-                elif len(lang) == 3:
-                     loadedMetadata.language = isoLanguages.get(part3=lang).name
-            else:
-                 loadedMetadata.language = ""
+            lang = loadedMetadata.language or ""
+            loadedMetadata.language = isoLanguages.get_lang3(lang)

            return BookMeta(
                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',
-                cover=_extractCover(tmp_file_path, original_file_extension, rarExceutable),
+                cover=_extractCover(tmp_file_path, original_file_extension, rarExecutable),
                description=loadedMetadata.comments or "",
                tags="",
                series=loadedMetadata.series or "",
@@ -137,7 +155,7 @@ def get_comic_info(tmp_file_path, original_file_name, original_file_extension, r
        extension=original_file_extension,
        title=original_file_name,
        author=u'Unknown',
-        cover=_extractCover(tmp_file_path, original_file_extension, rarExceutable),
+        cover=_extractCover(tmp_file_path, original_file_extension, rarExecutable),
        description="",
        tags="",
        series="",
@@ -19,10 +19,10 @@

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

-from sqlalchemy import exc, Column, String, Integer, SmallInteger, Boolean, BLOB
+from sqlalchemy import exc, Column, String, Integer, SmallInteger, Boolean, BLOB, JSON
+from sqlalchemy.exc import OperationalError
 from sqlalchemy.ext.declarative import declarative_base

 from . import constants, cli, logger, ub
@@ -53,9 +53,11 @@ class _Settings(_Base):
    mail_login = Column(String, default='mail@example.com')
    mail_password = Column(String, default='mypassword')
    mail_from = Column(String, default='automailer <mail@example.com>')
+    mail_size = Column(Integer, default=25*1024*1024)

    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)

@@ -91,35 +93,38 @@ class _Settings(_Base):

    config_use_google_drive = Column(Boolean, default=False)
    config_google_drive_folder = Column(String)
-    config_google_drive_watch_changes_response = Column(String)
+    config_google_drive_watch_changes_response = Column(JSON, default={})

    config_use_goodreads = Column(Boolean, default=False)
    config_goodreads_api_key = Column(String)
    config_goodreads_api_secret = Column(String)
-
+    config_register_email = Column(Boolean, default=False)
    config_login_type = Column(Integer, default=0)

    config_kobo_proxy = Column(Boolean, default=False)

-
    config_ldap_provider_url = Column(String, default='example.org')
    config_ldap_port = Column(SmallInteger, default=389)
    config_ldap_authentication = Column(SmallInteger, default=constants.LDAP_AUTH_SIMPLE)
    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')
    config_ldap_group_name = Column(String, default='calibreweb')

-    config_ebookconverter = Column(Integer, default=0)
-    config_converterpath = Column(String)
+    config_kepubifypath = Column(String, default=None)
+    config_converterpath = Column(String, default=None)
    config_calibre = Column(String)
-    config_rarfile_location = Column(String)
+    config_rarfile_location = Column(String, default=None)
+    config_upload_formats = Column(String, default=','.join(constants.EXTENSIONS_UPLOAD))

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

@@ -140,6 +145,22 @@ class _ConfigSQL(object):
        self.config_calibre_dir = None
        self.load()

+        change = False
+        if self.config_converterpath == None:
+            change = True
+            self.config_converterpath = autodetect_calibre_binary()
+
+        if self.config_kepubifypath == None:
+            change = True
+            self.config_kepubifypath = autodetect_kepubify_binary()
+
+        if self.config_rarfile_location == None:
+            change = True
+            self.config_rarfile_location = autodetect_unrar_binary()
+        if change:
+            self.save()
+
+
    def _read_from_storage(self):
        if self._settings is None:
            log.debug("_ConfigSQL._read_from_storage")
@@ -197,20 +218,20 @@ class _ConfigSQL(object):
        return self.show_element_new_user(constants.DETAIL_RANDOM)

    def list_denied_tags(self):
-        mct = self.config_denied_tags.split(",")
-        return [t.strip() for t in mct]
+        mct = self.config_denied_tags or ""
+        return [t.strip() for t in mct.split(",")]

    def list_allowed_tags(self):
-        mct = self.config_allowed_tags.split(",")
-        return [t.strip() for t in mct]
+        mct = self.config_allowed_tags or ""
+        return [t.strip() for t in mct.split(",")]

    def list_denied_column_values(self):
-        mct = self.config_denied_column_value.split(",")
-        return [t.strip() for t in mct]
+        mct = self.config_denied_column_value or ""
+        return [t.strip() for t in mct.split(",")]

    def list_allowed_column_values(self):
-        mct = self.config_allowed_column_value.split(",")
-        return [t.strip() for t in mct]
+        mct = self.config_allowed_column_value or ""
+        return [t.strip() for t in mct.split(",")]

    def get_log_level(self):
        return logger.get_level_name(self.config_log_level)
@@ -251,6 +272,14 @@ class _ConfigSQL(object):
        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
@@ -263,17 +292,23 @@ class _ConfigSQL(object):
                        v = column.default.arg
                setattr(self, k, v)

-        if self.config_google_drive_watch_changes_response:
-            self.config_google_drive_watch_changes_response = json.loads(self.config_google_drive_watch_changes_response)
-
        have_metadata_db = bool(self.config_calibre_dir)
        if have_metadata_db:
            if not self.config_use_google_drive:
                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
-
-        logger.setup(self.config_logfile, self.config_log_level)
+        constants.EXTENSIONS_UPLOAD = [x.lstrip().rstrip().lower() for x in self.config_upload_formats.split(',')]
+        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)
+            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.'''
@@ -287,7 +322,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):
@@ -328,19 +367,46 @@ def _migrate_table(session, orm_class):
                changed = True

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

 def autodetect_calibre_binary():
    if sys.platform == "win32":
-        calibre_path = ["C:\\program files\calibre\calibre-convert.exe",
-                        "C:\\program files(x86)\calibre\calibre-convert.exe"]
+        calibre_path = ["C:\\program files\\calibre\\ebook-convert.exe",
+                        "C:\\program files(x86)\\calibre\\ebook-convert.exe",
+                        "C:\\program files(x86)\\calibre2\\ebook-convert.exe",
+                        "C:\\program files\\calibre2\\ebook-convert.exe"]
    else:
        calibre_path = ["/opt/calibre/ebook-convert"]
    for element in calibre_path:
        if os.path.isfile(element) and os.access(element, os.X_OK):
            return element
-    return None
+    return ""

+def autodetect_unrar_binary():
+    if sys.platform == "win32":
+        calibre_path = ["C:\\program files\\WinRar\\unRAR.exe",
+                        "C:\\program files(x86)\\WinRar\\unRAR.exe"]
+    else:
+        calibre_path = ["/usr/bin/unrar"]
+    for element in calibre_path:
+        if os.path.isfile(element) and os.access(element, os.X_OK):
+            return element
+    return ""
+
+def autodetect_kepubify_binary():
+    if sys.platform == "win32":
+        calibre_path = ["C:\\program files\\kepubify\\kepubify-windows-64Bit.exe",
+                        "C:\\program files(x86)\\kepubify\\kepubify-windows-64Bit.exe"]
+    else:
+        calibre_path = ["/opt/kepubify/kepubify-linux-64bit", "/opt/kepubify/kepubify-linux-32bit"]
+    for element in calibre_path:
+        if os.path.isfile(element) and os.access(element, os.X_OK):
+            return element
+    return ""

 def _migrate_database(session):
    # make sure the table is created, if it does not exist
@@ -21,6 +21,7 @@ import sys
 import os
 from collections import namedtuple

+# if installed via pip this variable is set to true
 HOME_CONFIG = False

 # Base dir is parent of current file, necessary if called from different folder
@@ -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,9 +82,11 @@ SIDEBAR_PUBLISHER       = 1 << 12
 SIDEBAR_RATING          = 1 << 13
 SIDEBAR_FORMAT          = 1 << 14
 SIDEBAR_ARCHIVED        = 1 << 15
+SIDEBAR_DOWNLOAD        = 1 << 16
+SIDEBAR_LIST            = 1 << 17

 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
@@ -110,12 +113,11 @@ except ValueError:
 del env_CALIBRE_PORT


-EXTENSIONS_AUDIO    = {'mp3', 'm4a', 'm4b'}
-EXTENSIONS_CONVERT  = {'pdf', 'epub', 'mobi', 'azw3', 'docx', 'rtf', 'fb2', 'lit', 'lrf', 'txt', 'htmlz', 'rtf', 'odt'}
-EXTENSIONS_UPLOAD   = {'txt', 'pdf', 'epub', 'mobi', 'azw', 'azw3', 'cbr', 'cbz', 'cbt', 'djvu', 'prc', 'doc', 'docx',
-                       'fb2', 'html', 'rtf', 'lit', 'odt', 'mp3',  'm4a', 'm4b'}
-# EXTENSIONS_READER = set(['txt', 'pdf', 'epub', 'zip', 'cbz', 'tar', 'cbt'] +
-#                         (['rar','cbr'] if feature_support['rar'] else []))
+EXTENSIONS_AUDIO    = {'mp3', 'mp4', 'ogg', 'opus', 'wav', 'flac', 'm4a', 'm4b'}
+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'}


 def has_flag(value, bit_flag):
@@ -129,7 +131,7 @@ def selected_roles(dictionary):
 BookMeta = namedtuple('BookMeta', 'file_path, extension, title, author, cover, description, tags, series, '
                                  'series_id, languages')

-STABLE_VERSION = {'version': '0.6.7'}
+STABLE_VERSION = {'version': '0.6.11'}

 NIGHTLY_VERSION = {}
 NIGHTLY_VERSION[0] = '$Format:%H$'
@@ -29,8 +29,8 @@ log = logger.create()

 # _() necessary to make babel aware of string for translation
 _NOT_CONFIGURED = _('not configured')
-_NOT_INSTALLED = 'not installed'
-_EXECUTION_ERROR = 'Execution permissions missing'
+_NOT_INSTALLED = _('not installed')
+_EXECUTION_ERROR = _('Execution permissions missing')


 def _get_command_version(path, pattern, argument=None):
@@ -48,10 +48,15 @@ def _get_command_version(path, pattern, argument=None):
    return _NOT_INSTALLED


-def get_version():
-    version = None
-    if config.config_ebookconverter == 1:
-        version = _get_command_version(config.config_converterpath, r'Amazon kindlegen\(')
-    elif config.config_ebookconverter == 2:
-        version = _get_command_version(config.config_converterpath, r'ebook-convert.*\(calibre', '--version')
-    return version or _NOT_CONFIGURED
+def get_calibre_version():
+    return _get_command_version(config.config_converterpath, r'ebook-convert.*\(calibre', '--version') \
+           or _NOT_CONFIGURED
+
+
+def get_unrar_version():
+    return _get_command_version(config.config_rarfile_location, r'UNRAR.*\d') or _NOT_CONFIGURED
+
+def get_kepubify_version():
+    return _get_command_version(config.config_kepubifypath, r'kepubify\s','--version') or _NOT_CONFIGURED
+
+
@@ -22,59 +22,79 @@ import sys
 import os
 import re
 import ast
+import json
+from datetime import datetime

 from sqlalchemy import create_engine
-from sqlalchemy import Table, Column, ForeignKey
-from sqlalchemy import String, Integer, Boolean, TIMESTAMP, Float, DateTime
+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 declarative_base, DeclarativeMeta
+from sqlalchemy.pool import StaticPool
+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 . 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()

-session = None
 cc_exceptions = ['datetime', 'comments', 'composite', 'series']
 cc_classes = {}
-engine = None

 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):
    __tablename__ = 'identifiers'

    id = Column(Integer, primary_key=True)
-    type = Column(String)
-    val = Column(String)
-    book = Column(Integer, ForeignKey('books.id'))
+    type = Column(String(collation='NOCASE'), nullable=False, default="isbn")
+    val = Column(String(collation='NOCASE'), nullable=False)
+    book = Column(Integer, ForeignKey('books.id'), nullable=False)

    def __init__(self, val, id_type, book):
        self.val = val
@@ -82,41 +102,61 @@ class Identifiers(Base):
        self.book = book

    def formatType(self):
-        if self.type == "amazon":
+        format_type = self.type.lower()
+        if format_type == 'amazon':
            return u"Amazon"
-        elif self.type == "isbn":
+        elif format_type.startswith("amazon_"):
+            return u"Amazon.{0}".format(format_type[7:])
+        elif format_type == "isbn":
            return u"ISBN"
-        elif self.type == "doi":
+        elif format_type == "doi":
            return u"DOI"
-        elif self.type == "goodreads":
+        elif format_type == "douban":
+            return u"Douban"
+        elif format_type == "goodreads":
            return u"Goodreads"
-        elif self.type == "google":
+        elif format_type == "google":
            return u"Google Books"
-        elif self.type == "kobo":
+        elif format_type == "kobo":
            return u"Kobo"
-        if self.type == "lubimyczytac":
+        elif format_type == "litres":
+            return u"ЛитРес"
+        elif format_type == "issn":
+            return u"ISSN"
+        elif format_type == "isfdb":
+            return u"ISFDB"
+        if format_type == "lubimyczytac":
            return u"Lubimyczytac"
        else:
            return self.type

    def __repr__(self):
-        if self.type == "amazon":
-            return u"https://amzn.com/{0}".format(self.val)
-        elif self.type == "isbn":
-            return u"http://www.worldcat.org/isbn/{0}".format(self.val)
-        elif self.type == "doi":
-            return u"http://dx.doi.org/{0}".format(self.val)
-        elif self.type == "goodreads":
-            return u"http://www.goodreads.com/book/show/{0}".format(self.val)
-        elif self.type == "douban":
+        format_type = self.type.lower()
+        if format_type == "amazon" or format_type == "asin":
+            return u"https://amazon.com/dp/{0}".format(self.val)
+        elif format_type.startswith('amazon_'):
+            return u"https://amazon.{0}/dp/{1}".format(format_type[7:], self.val)
+        elif format_type == "isbn":
+            return u"https://www.worldcat.org/isbn/{0}".format(self.val)
+        elif format_type == "doi":
+            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 == "douban":
            return u"https://book.douban.com/subject/{0}".format(self.val)
-        elif self.type == "google":
+        elif format_type == "google":
            return u"https://books.google.com/books?id={0}".format(self.val)
-        elif self.type == "kobo":
+        elif format_type == "kobo":
            return u"https://www.kobo.com/ebook/{0}".format(self.val)
-        elif self.type == "lubimyczytac":
-            return u" http://lubimyczytac.pl/ksiazka/{0}".format(self.val)
-        elif self.type == "url":
+        elif format_type == "lubimyczytac":
+            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)
        else:
            return u""
@@ -126,13 +166,16 @@ class Comments(Base):
    __tablename__ = 'comments'

    id = Column(Integer, primary_key=True)
-    text = Column(String)
-    book = Column(Integer, ForeignKey('books.id'))
+    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)

@@ -141,11 +184,14 @@ class Tags(Base):
    __tablename__ = 'tags'

    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String)
+    name = Column(String(collation='NOCASE'), unique=True, nullable=False)

    def __init__(self, name):
        self.name = name

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

@@ -154,15 +200,18 @@ class Authors(Base):
    __tablename__ = 'authors'

    id = Column(Integer, primary_key=True)
-    name = Column(String)
-    sort = Column(String)
-    link = Column(String)
+    name = Column(String(collation='NOCASE'), unique=True, nullable=False)
+    sort = Column(String(collation='NOCASE'))
+    link = Column(String, nullable=False, default="")

    def __init__(self, name, sort, link):
        self.name = name
        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)

@@ -171,13 +220,16 @@ class Series(Base):
    __tablename__ = 'series'

    id = Column(Integer, primary_key=True)
-    name = Column(String)
-    sort = Column(String)
+    name = Column(String(collation='NOCASE'), unique=True, nullable=False)
+    sort = Column(String(collation='NOCASE'))

    def __init__(self, name, sort):
        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)

@@ -186,11 +238,14 @@ class Ratings(Base):
    __tablename__ = 'ratings'

    id = Column(Integer, primary_key=True)
-    rating = Column(Integer)
+    rating = Column(Integer, CheckConstraint('rating>-1 AND rating<11'), unique=True)

    def __init__(self, rating):
        self.rating = rating

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

@@ -199,11 +254,17 @@ class Languages(Base):
    __tablename__ = 'languages'

    id = Column(Integer, primary_key=True)
-    lang_code = Column(String)
+    lang_code = Column(String(collation='NOCASE'), nullable=False, unique=True)

    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)

@@ -212,25 +273,29 @@ class Publishers(Base):
    __tablename__ = 'publishers'

    id = Column(Integer, primary_key=True)
-    name = Column(String)
-    sort = Column(String)
+    name = Column(String(collation='NOCASE'), nullable=False, unique=True)
+    sort = Column(String(collation='NOCASE'))

    def __init__(self, name, sort):
        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'}

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

    def __init__(self, book, book_format, uncompressed_size, name):
        self.book = book
@@ -238,6 +303,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)

@@ -245,22 +314,25 @@ 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)
-    title = Column(String)
-    sort = Column(String)
-    author_sort = Column(String)
-    timestamp = Column(TIMESTAMP)
-    pubdate = Column(String)
-    series_index = Column(String)
-    last_modified = Column(TIMESTAMP)
-    path = Column(String)
-    has_cover = Column(Integer)
+    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(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')
-    tags = relationship('Tags', secondary=books_tags_link, backref='books',order_by="Tags.name")
+    tags = relationship('Tags', secondary=books_tags_link, backref='books', order_by="Tags.name")
    comments = relationship('Comments', backref='books')
    data = relationship('Data', backref='books')
    series = relationship('Series', secondary=books_series_link, backref='books')
@@ -279,7 +351,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,
@@ -290,6 +363,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'

@@ -310,131 +384,396 @@ class Custom_Columns(Base):
        return display_dict


-def update_title_sort(config, conn=None):
-    # user defined sort function for calibre databases (Series, etc.)
-    def _title_sort(title):
-        # calibre sort stuff
-        title_pat = re.compile(config.config_title_regex, re.IGNORECASE)
-        match = title_pat.search(title)
-        if match:
-            prep = match.group(1)
-            title = title.replace(prep, '') + ', ' + prep
-        return title.strip()
+class AlchemyEncoder(json.JSONEncoder):

-    conn = conn or session.connection().connection.connection
-    conn.create_function("title_sort", 1, _title_sort)
+    def default(self, obj):
+        if isinstance(obj.__class__, DeclarativeMeta):
+            # an SQLAlchemy class
+            fields = {}
+            for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
+                if field == 'books':
+                    continue
+                data = obj.__getattribute__(field)
+                try:
+                    if isinstance(data, str):
+                        data = data.replace("'", "\'")
+                    elif isinstance(data, InstrumentedList):
+                        el = list()
+                        for ele in data:
+                            if 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:
+                    fields[field] = ""
+            # a json-encodable dict
+            return fields
+
+        return json.JSONEncoder.default(self, obj)


-def setup_db(config):
-    dispose()
-    global engine
+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()

-    if not config.config_calibre_dir:
-        config.invalidate()
-        return False
+    def __init__(self, expire_on_commit=True):
+        """ Initialize a new CalibreDB session
+        """
+        self.session = None
+        if self._init:
+            self.initSession(expire_on_commit)

-    dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
-    if not os.path.exists(dbpath):
-        config.invalidate()
-        return False
+        self.instances.add(self)

-    try:
-        engine = create_engine('sqlite:///{0}'.format(dbpath),
-                               echo=False,
-                               isolation_level="SERIALIZABLE",
-                               connect_args={'check_same_thread': False})
-        conn = 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
-    update_title_sort(config, conn.connection)
+    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)

-    if not cc_classes:
-        cc = conn.execute("SELECT id, datatype FROM custom_columns")
+    @classmethod
+    def setup_db(cls, config, app_db_path):
+        cls.config = config
+        cls.dispose()
+
+        # toDo: if db changed -> delete shelfs, delete download books, delete read boks, kobo sync??
+
+        if not config.config_calibre_dir:
+            config.invalidate()
+            return False
+
+        dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
+        if not os.path.exists(dbpath):
+            config.invalidate()
+            return False
+
+        try:
+            cls.engine = create_engine('sqlite://',
+                                       echo=False,
+                                       isolation_level="SERIALIZABLE",
+                                       connect_args={'check_same_thread': False},
+                                       poolclass=StaticPool)
+            cls.engine.execute("attach database '{}' as calibre;".format(dbpath))
+            cls.engine.execute("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 e:
+            config.invalidate(e)
+            return False
+
+        config.db_configured = True
+
+        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,
+                                                         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])

-        cc_ids = []
-        books_custom_column_links = {}
-        for row in cc:
-            if row.datatype not in cc_exceptions:
-                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])
-                if row.datatype == 'bool':
                    ccdict = {'__tablename__': 'custom_column_' + str(row.id),
-                              'id': Column(Integer, primary_key=True),
-                              'book': Column(Integer, ForeignKey('books.id')),
-                              'value': Column(Boolean)}
-                elif row.datatype == 'int':
-                    ccdict = {'__tablename__': 'custom_column_' + str(row.id),
-                              'id': Column(Integer, primary_key=True),
-                              'book': Column(Integer, ForeignKey('books.id')),
-                              'value': Column(Integer)}
-                elif row.datatype == 'float':
-                    ccdict = {'__tablename__': 'custom_column_' + str(row.id),
-                              'id': Column(Integer, primary_key=True),
-                              'book': Column(Integer, ForeignKey('books.id')),
-                              'value': Column(Float)}
+                              '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'))
                else:
-                    ccdict = {'__tablename__': 'custom_column_' + str(row.id),
-                              'id': Column(Integer, primary_key=True),
-                              'value': Column(String)}
-                cc_classes[row.id] = type(str('Custom_Column_' + str(row.id)), (Base,), ccdict)
+                    setattr(Books,
+                            'custom_column_' + str(cc_id[0]),
+                            relationship(cc_classes[cc_id[0]],
+                                         secondary=books_custom_column_links[cc_id[0]],
+                                         backref='books'))

-        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'))
-            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'))
+        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). \
+            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()
+
+    # Language and content filters for displaying in the UI
+    def common_filters(self, allow_show_archived=False):
+        if not allow_show_archived:
+            archived_books = (
+                ub.session.query(ub.ArchivedBook)
+                    .filter(ub.ArchivedBook.user_id == int(current_user.id))
+                    .filter(ub.ArchivedBook.is_archived == True)
+                    .all()
+            )
+            archived_book_ids = [archived_book.book_id for archived_book in archived_books]
+            archived_filter = Books.id.notin_(archived_book_ids)
+        else:
+            archived_filter = true()
+
+        if current_user.filter_language() != "all":
+            lang_filter = Books.languages.any(Languages.lang_code == current_user.filter_language())
+        else:
+            lang_filter = true()
+        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))
+        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, 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)
+        else:
+            randm = false()
+        off = int(int(pagesize) * (page - 1))
+        query = self.session.query(database) \
+            .join(*join, isouter=True) \
+            .filter(db_filter) \
+            .filter(self.common_filters(allow_show_archived))
+        try:
+            pagination = Pagination(page, pagesize,
+                                    len(query.all()))
+            entries = query.order_by(*order).offset(off).limit(pagesize).all()
+        except Exception as e:
+            log.debug_or_exception(e)
+        #for book in entries:
+        #    book = self.order_authors(book)
+        return entries, randm, pagination
+
+    # Orders all Authors in the list according to authors sort
+    def order_authors(self, entry):
+        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
+            if not len(results):
+                error = True
+                break
+            for r in results:
+                if r.id in ids:
+                    authors_ordered.append(r)
+        if not error:
+            entry.authors = authors_ordered
+        return entry
+
+    def get_typeahead(self, database, query, replace=('', ''), tag_filter=true()):
+        query = query or ''
+        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=r.name.replace(*replace)) for r in entries])
+        return json_dumps
+
+    def check_exists_book(self, authr, title):
+        self.session.connection().connection.connection.create_function("lower", 1, lcase)
+        q = list()
+        authorterms = re.split(r'\s*&\s*', authr)
+        for authorterm in authorterms:
+            q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + authorterm + "%")))
+
+        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, offset=None, order=None, limit=None):
+        order = order or [Books.sort]
+        pagination = None
+        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 + "%")))
+        result = self.session.query(Books).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(*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):
+        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
+
+    def update_title_sort(self, config, conn=None):
+        # user defined sort function for calibre databases (Series, etc.)
+        def _title_sort(title):
+            # calibre sort stuff
+            title_pat = re.compile(config.config_title_regex, re.IGNORECASE)
+            match = title_pat.search(title)
+            if match:
+                prep = match.group(1)
+                title = title[len(prep):] + ', ' + prep
+            return title.strip()
+
+        conn = conn or self.session.connection().connection.connection
+        conn.create_function("title_sort", 1, _title_sort)
+
+    @classmethod
+    def dispose(cls):
+        # global session
+
+        for inst in cls.instances:
+            old_session = inst.session
+            inst.session = None
+            if old_session:
+                try:
+                    old_session.close()
+                except:
+                    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_"):
+                setattr(Books, attr, None)
+
+        for db_class in cc_classes.values():
+            Base.metadata.remove(db_class.__table__)
+        cc_classes.clear()
+
+        for table in reversed(Base.metadata.sorted_tables):
+            name = table.key
+            if name.startswith("custom_column_") or name.startswith("books_custom_column_"):
+                if table is not None:
+                    Base.metadata.remove(table)
+
+    def reconnect_db(self, config, app_db_path):
+        self.dispose()
+        self.engine.dispose()
+        self.setup_db(config, app_db_path)


-    global session
-    Session = scoped_session(sessionmaker(autocommit=False,
-                                             autoflush=False,
-                                             bind=engine))
-    session = Session()
-    return True
-
-
-def dispose():
-    global session
-
-    old_session = session
-    session = None
-    if old_session:
-        try: old_session.close()
-        except: 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_"):
-            setattr(Books, attr, None)
-
-    for db_class in cc_classes.values():
-        Base.metadata.remove(db_class.__table__)
-    cc_classes.clear()
-
-    for table in reversed(Base.metadata.sorted_tables):
-        name = table.key
-        if name.startswith("custom_column_") or name.startswith("books_custom_column_"):
-            if table is not None:
-                Base.metadata.remove(table)
-
-def reconnect_db(config):
-    session.close()
-    engine.dispose()
-    setup_db(config)
+def lcase(s):
+    try:
+        return unidecode.unidecode(s.lower())
+    except Exception as e:
+        log = logger.create()
+        log.debug_or_exception(e)
+        return s.lower()
@@ -0,0 +1,65 @@
+# -*- 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
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+import os
+
+from flask import send_file
+
+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 = StringIO()
+    for f in log_list:
+        with open(f, 'r') as fd:
+            shutil.copyfileobj(fd, wfd)
+    wfd.seek(0)
+    return send_file(wfd,
+                     as_attachment=True,
+                     attachment_filename=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)
+    return send_file(memory_zip,
+                     as_attachment=True,
+                     attachment_filename="Calibre-Web-debug-pack.zip")
@@ -22,9 +22,11 @@ import zipfile
 from lxml import etree

 from . import isoLanguages
+from .helper import split_authors
 from .constants import BookMeta


+
 def extractCover(zipFile, coverFile, coverpath, tmp_file_name):
    if coverFile is None:
        return None
@@ -64,11 +66,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(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'

@@ -82,16 +84,8 @@ def get_epub_info(tmp_file_path, original_file_name, original_file_extension):
        else:
            epub_metadata['description'] = ""

-    if epub_metadata['language'] == u'Unknown':
-        epub_metadata['language'] = ""
-    else:
-        lang = epub_metadata['language'].split('-', 1)[0].lower()
-        if len(lang) == 2:
-            epub_metadata['language'] = isoLanguages.get(part1=lang).name
-        elif len(lang) == 3:
-            epub_metadata['language'] = isoLanguages.get(part3=lang).name
-        else:
-            epub_metadata['language'] = ""
+    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:
@@ -122,9 +116,14 @@ def get_epub_info(tmp_file_path, original_file_name, original_file_extension):
                markupTree = etree.fromstring(markup)
                # no matter xhtml or html with no namespace
                imgsrc = markupTree.xpath("//*[local-name() = 'img']/@src")
-                # imgsrc maybe startwith "../"" so fullpath join then relpath to cwd
-                filename = os.path.relpath(os.path.join(os.path.dirname(os.path.join(coverpath, coversection[0])), imgsrc[0]))
-                coverfile = extractCover(epubZip, filename, "", tmp_file_path)
+                # Alternative image source
+                if not len(imgsrc):
+                    imgsrc = markupTree.xpath("//attribute::*[contains(local-name(), 'href')]")
+                if len(imgsrc):
+                    # imgsrc maybe startwith "../"" so fullpath join then relpath to cwd
+                    filename = os.path.relpath(os.path.join(os.path.dirname(os.path.join(coverpath, coversection[0])),
+                                                            imgsrc[0]))
+                    coverfile = extractCover(epubZip, filename, "", tmp_file_path)
            else:
                coverfile = extractCover(epubZip, coversection[0], coverpath, tmp_file_path)

@@ -0,0 +1,73 @@
+# -*- 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,
+                           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,
+                           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)
+        def handle_exception(e):
+            log.debug('LDAP server not accessible while trying to login to opds feed')
+            return error_http(FailedDependency())
+
+
+# @app.errorhandler(InvalidRequestError)
+#@app.errorhandler(OperationalError)
+#def handle_db_exception(e):
+#    db.session.rollback()
+#    log.error('Database request error: %s',e)
+#    return internal_error(InternalServerError(e))
@@ -34,24 +34,23 @@ 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 .admin import admin_required
+
+gdrive = Blueprint('gdrive', __name__, url_prefix='/gdrive')
+log = logger.create()
+
 try:
    from googleapiclient.errors import HttpError
-except ImportError:
-    pass
-
-from . import logger, gdriveutils, config, db
-from .web import admin_required
-
-
-gdrive = Blueprint('gdrive', __name__)
-log = logger.create()
+except ImportError as err:
+    log.debug("Cannot import googleapiclient, using GDrive will not work: %s", err)

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

 gdrive_watch_callback_token = 'target=calibreweb-watch_files'


-@gdrive.route("/gdrive/authenticate")
+@gdrive.route("/authenticate")
@login_required
@admin_required
 def authenticate_google_drive():
@@ -64,7 +63,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:
@@ -73,41 +72,37 @@ def google_drive_callback():
        credentials = gdriveutils.Gauth.Instance().auth.flow.step2_exchange(auth_code)
        with open(gdriveutils.CREDENTIALS, 'w') as f:
            f.write(credentials.to_json())
-    except ValueError as error:
+    except (ValueError, AttributeError) as error:
        log.error(error)
    return redirect(url_for('admin.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,
                               'web_hook', address, gdrive_watch_callback_token, current_milli_time() + 604800*1000)
-            config.config_google_drive_watch_changes_response = json.dumps(result)
-            # after save(), config_google_drive_watch_changes_response will be a json object, not string
+            config.config_google_drive_watch_changes_response = result
            config.save()
        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'))


-@gdrive.route("/gdrive/watch/revoke")
+@gdrive.route("/watch/revoke")
@login_required
@admin_required
 def revoke_watch_gdrive():
@@ -118,44 +113,48 @@ def revoke_watch_gdrive():
                                    last_watch_response['resourceId'])
        except HttpError:
            pass
-        config.config_google_drive_watch_changes_response = None
+        config.config_google_drive_watch_changes_response = {}
        config.save()
    return redirect(url_for('admin.configuration'))


-@gdrive.route("/gdrive/watch/callback", methods=['GET', 'POST'])
+@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 ''
+
    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.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:
+            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):
+                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)
-                        db.setup_db(config)
-            except Exception as e:
-                log.exception(e)
-        updateMetaData()
+                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 e:
+        log.debug_or_exception(e)
    return ''
@@ -20,6 +20,8 @@ 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
@@ -27,15 +29,28 @@ from sqlalchemy import Column, UniqueConstraint
 from sqlalchemy import String, Integer
 from sqlalchemy.orm import sessionmaker, scoped_session
 from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.exc import OperationalError, InvalidRequestError

 try:
-    from pydrive.auth import GoogleAuth
-    from pydrive.drive import GoogleDrive
-    from pydrive.auth import RefreshError
    from apiclient import errors
+    from httplib2 import ServerNotFoundError
+    importError = None
    gdrive_support = True
-except ImportError:
+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
+except ImportError as err:
+    try:
+        from pydrive.auth import GoogleAuth
+        from pydrive.drive import GoogleDrive
+        from pydrive.auth import RefreshError
+    except ImportError as err:
+        importError = err
+        gdrive_support = False

 from . import logger, cli, config
 from .constants import CONFIG_DIR as _CONFIG_DIR
@@ -50,6 +65,8 @@ if gdrive_support:
    logger.get('googleapiclient.discovery_cache').setLevel(logger.logging.ERROR)
    if not logger.is_debug_enabled():
        logger.get('googleapiclient.discovery').setLevel(logger.logging.ERROR)
+else:
+    log.debug("Cannot import pydrive,httplib2, using gdrive will not work: %s", importError)


 class Singleton:
@@ -83,7 +100,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

@@ -97,7 +114,11 @@ class Singleton:
@Singleton
 class Gauth:
    def __init__(self):
-        self.auth = GoogleAuth(settings_file=SETTINGS_YAML)
+        try:
+            self.auth = GoogleAuth(settings_file=SETTINGS_YAML)
+        except NameError as error:
+            log.error(error)
+            self.auth = None


@Singleton
@@ -178,7 +199,7 @@ def getDrive(drive=None, gauth=None):
            except RefreshError as e:
                log.error("Google Drive error: %s", e)
            except Exception as e:
-                log.exception(e)
+                log.debug_or_exception(e)
        else:
            # Initialize the saved creds
            gauth.Authorize()
@@ -192,14 +213,18 @@ def getDrive(drive=None, gauth=None):
    return drive

 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()
+    try:
+        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, ssl.SSLError) as e:
+        log.info("GDrive Error %s" % e)
+        fileList = []
    return fileList


 def getEbooksFolder(drive):
-    return getFolderInFolder('root',config.config_google_drive_folder,drive)
+    return getFolderInFolder('root', config.config_google_drive_folder, drive)


 def getFolderInFolder(parentId, folderName, drive):
@@ -229,7 +254,7 @@ def getEbooksFolderId(drive=None):
        gDriveId.path = '/'
        session.merge(gDriveId)
        session.commit()
-        return
+        return gDriveId.gdrive_id


 def getFile(pathId, fileName, drive):
@@ -369,7 +394,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:
@@ -474,8 +500,13 @@ def getChangeById (drive, change_id):

 # Deletes the local hashes database to force search for new folder names
 def deleteDatabaseOnChange():
-    session.query(GdriveId).delete()
-    session.commit()
+    try:
+        session.query(GdriveId).delete()
+        session.commit()
+    except (OperationalError, InvalidRequestError):
+        session.rollback()
+        log.info(u"GDrive DB is not Writeable")
+

 def updateGdriveCalibreFromLocal():
    copyToDrive(Gdrive.Instance().drive, config.config_calibre_dir, False, True)
@@ -526,21 +557,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 = """
@@ -583,8 +617,12 @@ def get_error_text(client_secrets=None):
    if not os.path.isfile(CLIENT_SECRETS):
        return 'client_secrets.json is missing or not readable'

-    with open(CLIENT_SECRETS, 'r') as settings:
-        filedata = json.load(settings)
+    try:
+        with open(CLIENT_SECRETS, 'r') as settings:
+            filedata = json.load(settings)
+    except PermissionError:
+        return 'client_secrets.json is missing or not readable'
+
    if 'web' not in filedata:
        return 'client_secrets.json is not configured for web application'
    if 'redirect_uris' not in filedata['web']:
@@ -21,9 +21,7 @@ from __future__ import division, print_function, unicode_literals
 import sys
 import os
 import io
-import json
 import mimetypes
-import random
 import re
 import shutil
 import time
@@ -32,14 +30,12 @@ from datetime import datetime, timedelta
 from tempfile import gettempdir

 import requests
-from babel import Locale as LC
-from babel.core import UnknownLocaleError
 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, request
 from flask_babel import gettext as _
 from flask_login import current_user
-from sqlalchemy.sql.expression import true, false, and_, or_, text, func
+from sqlalchemy.sql.expression import true, false, and_, text
 from werkzeug.datastructures import Headers
 from werkzeug.security import generate_password_hash

@@ -54,85 +50,91 @@ try:
 except ImportError:
    use_unidecode = False

-try:
-    from PIL import Image as PILImage
-    use_PIL = True
-except ImportError:
-    use_PIL = False
-
-from . import logger, config, get_locale, db, ub, isoLanguages, worker
+from . import calibre_db
+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 .pagination import Pagination
 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
+    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 = db.session.query(db.Books).filter(db.Books.id == book_id).first()
-    data = db.session.query(db.Data).filter(db.Data.book == book.id).filter(db.Data.format == old_book_format).first()
+    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()
-        text = (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, text, 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()
+    txt = (u"%s -> %s: %s" % (
+           old_book_format,
+           new_book_format,
+           "<a href=\"" + url_for('web.show_book', book_id=book.id) + "\">" + book.title + "</a>"))
+    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


@@ -142,25 +144,27 @@ def check_send_to_kindle(entry):
    """
    if len(entry.data):
        bookformats = list()
-        if config.config_ebookconverter == 0:
+        if not config.config_converterpath:
            # no converter - only for mobi and pdf formats
            for ele in iter(entry.data):
-                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')})
+                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):
-                formats.append(ele.format)
+                if ele.uncompressed_size < config.mail_size:
+                    formats.append(ele.format)
            if 'MOBI' in formats:
                bookformats.append({'format': 'Mobi',
                                    'convert': 0,
@@ -173,14 +177,13 @@ def check_send_to_kindle(entry):
                bookformats.append({'format': 'Pdf',
                                    'convert': 0,
                                    'text': _('Send %(format)s to Kindle', format='Pdf')})
-            if config.config_ebookconverter >= 1:
-                if 'EPUB' in formats and not 'MOBI' in formats:
+            if config.config_converterpath:
+                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 config.config_ebookconverter == 2:
                if 'AZW3' in formats and not 'MOBI' in formats:
                    bookformats.append({'format': 'Mobi',
                                        'convert': 2,
@@ -211,7 +214,7 @@ def check_read_formats(entry):
 # 3: If Pdf file is existing, it's directly send to kindle email
 def send_mail(book_id, book_format, convert, kindle_mail, calibrepath, user_id):
    """Send email with attachments"""
-    book = db.session.query(db.Books).filter(db.Books.id == book_id).first()
+    book = calibre_db.get_book(book_id)

    if convert == 1:
        # returns None if success, otherwise errormessage
@@ -223,9 +226,9 @@ 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.'))
+            WorkerThread.add(user_id, TaskEmail(_(u"Send to Kindle"), book.path, converted_file_name,
+                             config.get_mail_settings(), kindle_mail,
+                             _(u"E-mail: %(book)s", book=book.title), _(u'This e-mail has been sent via Calibre-Web.')))
            return
    return _(u"The requested file could not be read. Maybe wrong permissions?")

@@ -239,22 +242,22 @@ 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)).strip()
+        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).strip()
+            value = re_slugify.sub('', value)
        else:
-            value = unicode(re_slugify.sub('', value).strip())
+            value = unicode(re_slugify.sub('', value))
    if replace_whitespace:
        #  *+:\"/<>? are replaced by _
-        value = re.sub(r'[\*\+:\\\"/<>\?]+', u'_', value, flags=re.U)
+        value = re.sub(r'[*+:\\\"/<>?]+', u'_', value, flags=re.U)
        # pipe has to be replaced with comma
-        value = re.sub(r'[\|]+', u',', value, flags=re.U)
-    value = value[:128]
+        value = re.sub(r'[|]+', u',', value, flags=re.U)
+    value = value[:128].strip()
    if not value:
        raise ValueError("Filename cannot be empty")
    if sys.version_info.major == 3:
@@ -263,6 +266,22 @@ def get_valid_filename(value, replace_whitespace=True):
        return value.decode('utf-8')


+def split_authors(values):
+    authors_list = []
+    for value in values:
+        authors = re.split('[&;]', value)
+        for author in authors:
+            commas = author.count(',')
+            if commas == 1:
+                author_split = author.split(',')
+                authors_list.append(author_split[1].strip() + ' ' + author_split[0].strip())
+            elif commas > 1:
+                authors_list.extend([x.strip() for x in author.split(',')])
+            else:
+                authors_list.append(author.strip())
+    return authors_list
+
+
 def get_sorted_author(value):
    try:
        if ',' not in value:
@@ -270,7 +289,10 @@ def get_sorted_author(value):
            combined = "(" + ")|(".join(regexes) + ")"
            value = value.split(" ")
            if re.match(combined, value[-1].upper()):
-                value2 = value[-2] + ", " + " ".join(value[:-2]) + " " + value[-1]
+                if len(value) > 1:
+                    value2 = value[-2] + ", " + " ".join(value[:-2]) + " " + value[-1]
+                else:
+                    value2 = value[0]
            elif len(value) == 1:
                value2 = value[0]
            else:
@@ -279,7 +301,10 @@ def get_sorted_author(value):
            value2 = value
    except Exception as ex:
        log.error("Sorting author %s failed: %s", value, ex)
-        value2 = value
+        if isinstance(list, value2):
+            value2 = value[0]
+        else:
+            value2 = value
    return value2


@@ -295,15 +320,16 @@ def delete_book_file(book, calibrepath, book_format=None):
            return True, None
        else:
            if os.path.isdir(path):
-                if len(next(os.walk(path))[1]):
-                    log.error("Deleting book %s failed, path has subfolders: %s", book.id, book.path)
-                    return False , _("Deleting book %(id)s failed, path has subfolders: %(path)s",
-                                     id=book.id,
-                                     path=book.path)
                try:
-                    for root, __, files in os.walk(path):
+                    for root, folders, files in os.walk(path):
                        for f in files:
                            os.unlink(os.path.join(root, f))
+                        if len(folders):
+                            log.warning("Deleting book {} failed, path {} has subfolders: {}".format(book.id,
+                                        book.path, folders))
+                            return True, _("Deleting bookfolder for book %(id)s failed, path has subfolders: %(path)s",
+                                           id=book.id,
+                                           path=book.path)
                    shutil.rmtree(path)
                except (IOError, OSError) as e:
                    log.error("Deleting book %s failed: %s", book.id, e)
@@ -317,72 +343,82 @@ def delete_book_file(book, calibrepath, book_format=None):
                return True, None
            else:
                log.error("Deleting book %s failed, book path not valid: %s", book.id, book.path)
-                return False, _("Deleting book %(id)s failed, book path not valid: %(path)s",
-                                     id=book.id,
-                                     path=book.path)
+                return True, _("Deleting book %(id)s, book path not valid: %(path)s",
+                               id=book.id,
+                               path=book.path)


-def update_dir_structure_file(book_id, calibrepath, first_author):
-    localbook = db.session.query(db.Books).filter(db.Books.id == book_id).first()
-    path = os.path.join(calibrepath, localbook.path)
+# 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)
+    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(path, 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.join(dir_name, file),
-                                   os.path.join(new_title_path + dir_name[len(path):], file))
-            path = new_title_path
-            localbook.path = localbook.path.split('/')[0] + '/' + new_titledir
+                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_title_path, 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(path, 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:
-        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.join(path_name, file_format.name + '.' + file_format.format.lower()),
-                           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
+            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", path, new_name, 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 = db.session.query(db.Books).filter(db.Books.id == book_id).first()
+    book = calibre_db.get_book(book_id)
    path = book.path

    authordir = book.path.split('/')[0]
@@ -450,11 +486,11 @@ def reset_password(user_id):
    existing_user = ub.session.query(ub.User).filter(ub.User.id == user_id).first()
    if not existing_user:
        return 0, None
-    password = generate_random_password()
-    existing_user.password = generate_password_hash(password)
    if not config.get_mail_server_configured():
        return 2, None
    try:
+        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
@@ -466,16 +502,27 @@ def reset_password(user_id):
 def generate_random_password():
    s = "abcdefghijklmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%&*()?"
    passlen = 8
-    return "".join(random.sample(s, passlen))
-
-################################## External interface
+    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))


-def update_dir_stucture(book_id, calibrepath, first_author=None):
+def uniq(inpt):
+    output = []
+    for x in inpt:
+        if x not in output:
+            output.append(x)
+    return output
+
+# ################################# External interface #################################
+
+
+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):
@@ -493,18 +540,17 @@ def get_cover_on_failure(use_generic_cover):


 def get_book_cover(book_id):
-    book = db.session.query(db.Books).filter(db.Books.id == book_id).filter(common_filters()).first()
+    book = calibre_db.get_filtered_book(book_id, allow_show_archived=True)
    return get_book_cover_internal(book, use_generic_cover_on_failure=True)


 def get_book_cover_with_uuid(book_uuid,
                             use_generic_cover_on_failure=True):
-    book = db.session.query(db.Books).filter(db.Books.uuid == book_uuid).first()
+    book = calibre_db.get_book_by_uuid(book_uuid)
    return get_book_cover_internal(book, use_generic_cover_on_failure)


-def get_book_cover_internal(book,
-                            use_generic_cover_on_failure):
+def get_book_cover_internal(book, use_generic_cover_on_failure):
    if book and book.has_cover:
        if config.config_use_google_drive:
            try:
@@ -517,8 +563,7 @@ def get_book_cover_internal(book,
                    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()
+                log.debug_or_exception(e)
                return get_cover_on_failure(use_generic_cover_on_failure)
        else:
            cover_file_path = os.path.join(config.config_calibre_dir, book.path)
@@ -532,15 +577,24 @@ def get_book_cover_internal(book,

 # saves book cover from url
 def save_cover_from_url(url, book_path):
-    img = requests.get(url, timeout=10)      # ToDo: Error Handling
-    return save_cover(img, book_path)
+    try:
+        img = requests.get(url, timeout=(10, 200))      # ToDo: Error Handling
+        img.raise_for_status()
+        return save_cover(img, book_path)
+    except (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 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()
+    if hasattr(img,"metadata"):
+        img.save(filename=os.path.join(filepath, saved_filename))
+        img.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):
@@ -561,31 +615,33 @@ 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 content_type != 'image/jpg':
            if hasattr(img, 'stream'):
-                imgc = PILImage.open(img.stream)
+                imgc = Image(blob=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()
+                imgc = Image(blob=io.BytesIO(img.content))
+            imgc.format = 'jpeg'
+            imgc.transform_colorspace("rgb")
+            img = imgc
    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:
@@ -594,7 +650,7 @@ def save_cover(img, book_path):
        return save_cover_from_filestorage(os.path.join(config.config_calibre_dir, book_path), "cover.jpg", img)


-def do_download_file(book, book_format, data, headers):
+def do_download_file(book, book_format, client, data, headers):
    if config.config_use_google_drive:
        startTime = time.time()
        df = gd.getFileFromEbooksFolder(book.path, data.name + "." + book_format)
@@ -608,8 +664,14 @@ def do_download_file(book, book_format, data, headers):
        if not os.path.isfile(os.path.join(filename, data.name + "." + book_format)):
            # ToDo: improve error handling
            log.error('File not found: %s', os.path.join(filename, data.name + "." + book_format))
+
+        if client == "kobo" and book_format == "kepub":
+            headers["Content-Disposition"] = headers["Content-Disposition"].replace(".kepub", ".kepub.epub")
+
        response = make_response(send_from_directory(filename, data.name + "." + book_format))
-        response.headers = headers
+        # ToDo Check headers parameter
+        for element in headers:
+            response.headers[element[0]] = element[1]
        return response

 ##################################
@@ -627,12 +689,13 @@ def check_unrar(unrarLocation):
            unrarLocation = unrarLocation.encode(sys.getfilesystemencoding())
        unrarLocation = [unrarLocation]
        for lines in process_wait(unrarLocation):
-            value = re.search('UNRAR (.*) freeware', lines)
+            value = re.search('UNRAR (.*) freeware', lines, re.IGNORECASE)
            if value:
                version = value.group(1)
                log.debug("unrar version %s", version)
-    except OSError as err:
-        log.exception(err)
+                break
+    except (OSError, UnicodeDecodeError) as err:
+        log.debug_or_exception(err)
        return _('Error excecuting UnRar')


@@ -672,111 +735,40 @@ 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 num, user, added, task in tasklist:
+        if user == current_user.nickname 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'] = user
+            renderedtasklist.append(ret)

    return renderedtasklist


-# Language and content filters for displaying in the UI
-def common_filters(allow_show_archived=False):
-    if not allow_show_archived:
-        archived_books = (
-            ub.session.query(ub.ArchivedBook)
-            .filter(ub.ArchivedBook.user_id == int(current_user.id))
-            .filter(ub.ArchivedBook.is_archived == True)
-            .all()
-        )
-        archived_book_ids = [archived_book.book_id for archived_book in archived_books]
-        archived_filter = db.Books.id.notin_(archived_book_ids)
-    else:
-        archived_filter = true()
-
-    if current_user.filter_language() != "all":
-        lang_filter = db.Books.languages.any(db.Languages.lang_code == current_user.filter_language())
-    else:
-        lang_filter = true()
-    negtags_list = current_user.list_denied_tags()
-    postags_list = current_user.list_allowed_tags()
-    neg_content_tags_filter = false() if negtags_list == [''] else db.Books.tags.any(db.Tags.name.in_(negtags_list))
-    pos_content_tags_filter = true() if postags_list == [''] else db.Books.tags.any(db.Tags.name.in_(postags_list))
-    if config.config_restricted_column:
-        pos_cc_list = current_user.allowed_column_value.split(',')
-        pos_content_cc_filter = true() if pos_cc_list == [''] else \
-            getattr(db.Books, 'custom_column_' + str(config.config_restricted_column)).\
-                    any(db.cc_classes[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(db.Books, 'custom_column_' + str(config.config_restricted_column)).\
-                    any(db.cc_classes[config.config_restricted_column].value.in_(neg_cc_list))
-    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)
-
-
 def tags_filters():
    negtags_list = current_user.list_denied_tags()
    postags_list = current_user.list_allowed_tags()
    neg_content_tags_filter = false() if negtags_list == [''] else db.Tags.name.in_(negtags_list)
    pos_content_tags_filter = true() if postags_list == [''] else db.Tags.name.in_(postags_list)
    return and_(pos_content_tags_filter, ~neg_content_tags_filter)
-    # return ~(false()) if postags_list == [''] else db.Tags.in_(postags_list)
-
-
-# Creates for all stored languages a translated speaking name in the array for the UI
-def speaking_language(languages=None):
-    if not languages:
-        languages = db.session.query(db.Languages).join(db.books_languages_link).join(db.Books)\
-            .filter(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


 # checks if domain is in database (including wildcards)
@@ -793,93 +785,29 @@ def check_valid_domain(domain_text):
    return not len(result)


-# Orders all Authors in the list according to authors sort
-def order_authors(entry):
-    sort_authors = entry.author_sort.split('&')
-    authors_ordered = list()
-    error = False
-    for auth in sort_authors:
-        # ToDo: How to handle not found authorname
-        result = db.session.query(db.Authors).filter(db.Authors.sort == auth.lstrip().strip()).first()
-        if not result:
-            error = True
-            break
-        authors_ordered.append(result)
-    if not error:
-        entry.authors = authors_ordered
-    return entry
-
-
-# Fill indexpage with all requested data from database
-def fill_indexpage(page, database, db_filter, order, *join):
-    return fill_indexpage_with_archived_books(page, database, db_filter, order, False, *join)
-
-
-def fill_indexpage_with_archived_books(page, database, db_filter, order, allow_show_archived, *join):
-    if current_user.show_detail_random():
-        randm = db.session.query(db.Books).filter(common_filters(allow_show_archived))\
-            .order_by(func.random()).limit(config.config_random_books)
-    else:
-        randm = false()
-    off = int(int(config.config_books_per_page) * (page - 1))
-    pagination = Pagination(page, config.config_books_per_page,
-                            len(db.session.query(database).filter(db_filter)
-                                .filter(common_filters(allow_show_archived)).all()))
-    entries = db.session.query(database).join(*join, isouter=True).filter(db_filter)\
-        .filter(common_filters(allow_show_archived))\
-        .order_by(*order).offset(off).limit(config.config_books_per_page).all()
-    for book in entries:
-        book = order_authors(book)
-    return entries, randm, pagination
-
-
-def get_typeahead(database, query, replace=('', ''), tag_filter=true()):
-    query = query or ''
-    db.session.connection().connection.connection.create_function("lower", 1, lcase)
-    entries = db.session.query(database).filter(tag_filter).\
-        filter(func.lower(database.name).ilike("%" + query + "%")).all()
-    json_dumps = json.dumps([dict(name=r.name.replace(*replace)) for r in entries])
-    return json_dumps
-
-
-# read search results from calibre-database and return it (function is used for feed and simple search
-def get_search_results(term):
-    db.session.connection().connection.connection.create_function("lower", 1, lcase)
-    q = list()
-    authorterms = re.split("[, ]+", term)
-    for authorterm in authorterms:
-        q.append(db.Books.authors.any(func.lower(db.Authors.name).ilike("%" + authorterm + "%")))
-
-    db.Books.authors.any(func.lower(db.Authors.name).ilike("%" + term + "%"))
-
-    return db.session.query(db.Books).filter(common_filters()).filter(
-        or_(db.Books.tags.any(func.lower(db.Tags.name).ilike("%" + term + "%")),
-            db.Books.series.any(func.lower(db.Series.name).ilike("%" + term + "%")),
-            db.Books.authors.any(and_(*q)),
-            db.Books.publishers.any(func.lower(db.Publishers.name).ilike("%" + term + "%")),
-            func.lower(db.Books.title).ilike("%" + term + "%")
-            )).order_by(db.Books.sort).all()
-
-
-def get_cc_columns():
-    tmpcc = db.session.query(db.Custom_Columns).filter(db.Custom_Columns.datatype.notin_(db.cc_exceptions)).all()
+def get_cc_columns(filter_config_custom_read=False):
+    tmpcc = calibre_db.session.query(db.Custom_Columns)\
+        .filter(db.Custom_Columns.datatype.notin_(db.cc_exceptions)).all()
+    cc = []
+    r = None
    if config.config_columns_to_ignore:
-        cc = []
-        for col in tmpcc:
-            r = re.compile(config.config_columns_to_ignore)
-            if not r.match(col.name):
-                cc.append(col)
-    else:
-        cc = tmpcc
+        r = re.compile(config.config_columns_to_ignore)
+
+    for col in tmpcc:
+        if filter_config_custom_read and config.config_read_column and config.config_read_column == col.id:
+            continue
+        if r and r.match(col.name):
+            continue
+        cc.append(col)
+
    return cc


-def get_download_link(book_id, book_format):
+def get_download_link(book_id, book_format, client):
    book_format = book_format.split(".")[0]
-    book = db.session.query(db.Books).filter(db.Books.id == book_id).filter(common_filters()).first()
+    book = calibre_db.get_filtered_book(book_id)
    if book:
-        data1 = db.session.query(db.Data).filter(db.Data.book == book.id)\
-            .filter(db.Data.format == book_format.upper()).first()
+        data1 = calibre_db.get_book_format(book.id, book_format.upper())
    else:
        abort(404)
    if data1:
@@ -894,28 +822,6 @@ def get_download_link(book_id, book_format):
        headers["Content-Type"] = mimetypes.types_map.get('.' + book_format, "application/octet-stream")
        headers["Content-Disposition"] = "attachment; filename=%s.%s; filename*=UTF-8''%s.%s" % (
            quote(file_name.encode('utf-8')), book_format, quote(file_name.encode('utf-8')), book_format)
-        return do_download_file(book, book_format, data1, headers)
+        return do_download_file(book, book_format, client, data1, headers)
    else:
        abort(404)
-
-
-def check_exists_book(authr, title):
-    db.session.connection().connection.connection.create_function("lower", 1, lcase)
-    q = list()
-    authorterms = re.split(r'\s*&\s*', authr)
-    for authorterm in authorterms:
-        q.append(db.Books.authors.any(func.lower(db.Authors.name).ilike("%" + authorterm + "%")))
-
-    return db.session.query(db.Books).filter(
-        and_(db.Books.authors.any(and_(*q)),
-             func.lower(db.Books.title).ilike("%" + title + "%")
-             )).first()
-
-############### Database Helper functions
-
-
-def lcase(s):
-    try:
-        return unidecode.unidecode(s.lower())
-    except Exception as e:
-        log.exception(e)
@@ -57,12 +57,36 @@ def get_language_name(locale, lang_code):

 def get_language_codes(locale, language_names, remainder=None):
    language_names = set(x.strip().lower() for x in language_names if x)
-
+    languages = list()
    for k, v in get_language_names(locale).items():
        v = v.lower()
        if v in language_names:
+            languages.append(k)
            language_names.remove(v)
-            yield k
-
    if remainder is not None:
        remainder.extend(language_names)
+    return languages
+
+def get_valid_language_codes(locale, language_names, remainder=None):
+    languages = list()
+    if "" in language_names:
+        language_names.remove("")
+    for k, v in get_language_names(locale).items():
+        if k in language_names:
+            languages.append(k)
+            language_names.remove(k)
+    if remainder is not None and len(language_names):
+        remainder.extend(language_names)
+    return languages
+
+def get_lang3(lang):
+    try:
+        if len(lang) == 2:
+            ret_value = get(part1=lang).part3
+        elif len(lang) == 3:
+            ret_value = lang
+        else:
+            ret_value = ""
+    except KeyError:
+        ret_value = lang
+    return ret_value
@@ -25,7 +25,7 @@
 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
@@ -44,6 +44,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 +78,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
                  )
-        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


@@ -113,8 +111,25 @@ def yesno(value, yes, no):
    return yes if value else no


-'''@jinjia.app_template_filter('canread')
-def canread(ext):
-    if isinstance(ext, db.Data):
-        ext = ext.format
-    return ext.lower() in EXTENSIONS_READER'''
+@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
+
+
+@jinjia.app_template_filter('formatseriesindex')
+def formatseriesindex_filter(series_index):
+    if series_index:
+        if int(series_index) - series_index == 0:
+            return int(series_index)
+        else:
+            return series_index
+    return 0
+
+@jinjia.app_template_filter('uuidfilter')
+def uuidfilter(var):
+    return uuid4()
+
+
@@ -19,8 +19,6 @@

 import base64
 import datetime
-import itertools
-import json
 import sys
 import os
 import uuid
@@ -41,22 +39,26 @@ 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.orm import load_only
 from sqlalchemy.exc import StatementError
 import requests

-from . import config, logger, kobo_auth, db, helper, shelf as shelf_lib, ub
+from . import config, logger, kobo_auth, db, calibre_db, helper, shelf as shelf_lib, ub
+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)
@@ -121,7 +123,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")
@@ -131,7 +137,7 @@ def HandleSyncRequest():
    sync_token = SyncToken.SyncToken.from_headers(request.headers)
    log.info("Kobo library sync request received.")
    if not current_app.wsgi_app.is_proxied:
-        log.debug('Kobo: Received unproxied request, changed request port to server port')
+        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.
@@ -139,75 +145,91 @@ def HandleSyncRequest():
    new_books_last_modified = sync_token.books_last_modified
    new_books_last_created = sync_token.books_last_created
    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).
-    db.reconnect_db(config)
+    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()
-    )
-
-    # 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)
-
-    # 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 = (
-        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()
-    )
+    if sync_token.books_last_id > -1:
+        changed_entries = (
+            calibre_db.session.query(db.Books, ub.ArchivedBook.last_modified, ub.ArchivedBook.is_archived)
+            .join(db.Data).outerjoin(ub.ArchivedBook, db.Books.id == ub.ArchivedBook.book_id)
+            .filter(db.Books.last_modified >= sync_token.books_last_modified)
+            .filter(db.Books.id>sync_token.books_last_id)
+            .filter(db.Data.format.in_(KOBO_FORMATS))
+            .order_by(db.Books.last_modified)
+            .order_by(db.Books.id)
+            .limit(SYNC_ITEM_LIMIT)
+        )
+    else:
+        changed_entries = (
+            calibre_db.session.query(db.Books, ub.ArchivedBook.last_modified, ub.ArchivedBook.is_archived)
+            .join(db.Data).outerjoin(ub.ArchivedBook, db.Books.id == ub.ArchivedBook.book_id)
+            .filter(db.Books.last_modified > sync_token.books_last_modified)
+            .filter(db.Data.format.in_(KOBO_FORMATS))
+            .order_by(db.Books.last_modified)
+            .order_by(db.Books.id)
+            .limit(SYNC_ITEM_LIMIT)
+        )

    reading_states_in_new_entitlements = []
    for book in changed_entries:
-        kobo_reading_state = get_or_create_reading_state(book.id)
+        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.nickname)
+
+        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:
+        if book.Books.timestamp > 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)
+        new_books_last_created = max(book.Books.timestamp, new_books_last_created)

+    max_change = (changed_entries
+        .from_self()
+        .filter(ub.ArchivedBook.is_archived)
+        .order_by(func.datetime(ub.ArchivedBook.last_modified).desc())
+        .first()
+    )
+    if max_change:
+        max_change = max_change.last_modified
+    else:
+        max_change = new_archived_last_modified
+    new_archived_last_modified = max(new_archived_last_modified, max_change)
+
+    # no. of books returned
+    book_count = changed_entries.count()
+
+    # last entry:
+    if book_count:
+        books_last_id = changed_entries.all()[-1].Books.id or -1
+    else:
+        books_last_id = -1
+
+    # generate reading state data
    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():
-        book = db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none()
+        book = calibre_db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none()
        if book:
            sync_results.append({
                "ChangedReadingState": {
@@ -222,11 +244,12 @@ def HandleSyncRequest():
    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
+    sync_token.books_last_id = books_last_id

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


-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:
        # Merge in sync results from the official Kobo store.
@@ -242,6 +265,8 @@ def generate_sync_response(sync_token, sync_results):

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

    response = make_response(jsonify(sync_results), extra_headers)
@@ -254,9 +279,9 @@ def generate_sync_response(sync_token, sync_results):
@download_required
 def HandleMetadataRequest(book_uuid):
    if not current_app.wsgi_app.is_proxied:
-        log.debug('Kobo: Received unproxied request, changed request port to server port')
+        log.debug('Kobo: Received unproxied request, changed request port to external server port')
    log.info("Kobo library metadata request received for book %s" % book_uuid)
-    book = db.session.query(db.Books).filter(db.Books.uuid == book_uuid).first()
+    book = calibre_db.get_book_by_uuid(book_uuid)
    if not book or not book.data:
        log.info(u"Book %s not found in database", book_uuid)
        return redirect_or_proxy_request()
@@ -267,14 +292,16 @@ def HandleMetadataRequest(book_uuid):

 def get_download_url_for_book(book, book_format):
    if not current_app.wsgi_app.is_proxied:
-        if ':' in request.host and not request.host.endswith(']') :
+        if ':' in request.host and not request.host.endswith(']'):
            host = "".join(request.host.split(':')[:-1])
        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_port,
+            url_port=config.config_external_port,
+            auth_token=get_auth_token(),
            book_id=book.id,
            book_format=book_format.lower()
        )
@@ -317,8 +344,15 @@ def get_description(book):
 # TODO handle multiple authors
 def get_author(book):
    if not book.authors:
-        return None
-    return book.authors[0].name
+        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}


 def get_publisher(book):
@@ -332,10 +366,15 @@ def get_series(book):
        return None
    return book.series[0].name

+def get_seriesindex(book):
+    return book.series_index or 1
+

 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]:
@@ -354,7 +393,7 @@ def get_metadata(book):
    book_uuid = book.uuid
    metadata = {
        "Categories": ["00000000-0000-0000-0000-000000000001",],
-        "Contributors": get_author(book),
+        # "Contributors": get_author(book),
        "CoverImageId": book_uuid,
        "CrossRevisionId": book_uuid,
        "CurrentDisplayPrice": {"CurrencyCode": "USD", "TotalAmount": 0},
@@ -378,6 +417,7 @@ def get_metadata(book):
        "Title": book.title,
        "WorkId": book_uuid,
    }
+    metadata.update(get_author(book))

    if get_series(book):
        if sys.version_info < (3, 0):
@@ -386,8 +426,8 @@ def get_metadata(book):
            name = get_series(book)
        metadata["Series"] = {
            "Name": get_series(book),
-            "Number": book.series_index,        # ToDo Check int() ?
-            "NumberFloat": float(book.series_index),
+            "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),
        }
@@ -396,7 +436,7 @@ def get_metadata(book):


@kobo.route("/v1/library/tags", methods=["POST", "DELETE"])
-@login_required
+@requires_kobo_auth
 # Creates a Shelf with the given items, and returns the shelf's uuid.
 def HandleTagCreate():
    # catch delete requests, otherwise the are handeld in the book delete handler
@@ -425,12 +465,12 @@ 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)


@kobo.route("/v1/library/tags/<tag_id>", methods=["DELETE", "PUT"])
+@requires_kobo_auth
 def HandleTagUpdate(tag_id):
    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id,
                                              ub.Shelf.user_id == current_user.id).one_or_none()
@@ -457,7 +497,7 @@ def HandleTagUpdate(tag_id):

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


@@ -471,7 +511,7 @@ def add_items_to_shelf(items, shelf):
                items_unknown_to_calibre.append(item)
                continue

-            book = db.session.query(db.Books).filter(db.Books.uuid == item["RevisionId"]).one_or_none()
+            book = calibre_db.get_book_by_uuid(item["RevisionId"])
            if not book:
                items_unknown_to_calibre.append(item)
                continue
@@ -485,7 +525,7 @@ def add_items_to_shelf(items, shelf):


@kobo.route("/v1/library/tags/<tag_id>/items", methods=["POST"])
-@login_required
+@requires_kobo_auth
 def HandleTagAddItem(tag_id):
    items = None
    try:
@@ -509,13 +549,12 @@ 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)


@kobo.route("/v1/library/tags/<tag_id>/items/delete", methods=["POST"])
-@login_required
+@requires_kobo_auth
 def HandleTagRemoveItem(tag_id):
    items = None
    try:
@@ -542,7 +581,7 @@ def HandleTagRemoveItem(tag_id):
                items_unknown_to_calibre.append(item)
                continue

-            book = db.session.query(db.Books).filter(db.Books.uuid == item["RevisionId"]).one_or_none()
+            book = calibre_db.get_book_by_uuid(item["RevisionId"])
            if not book:
                items_unknown_to_calibre.append(item)
                continue
@@ -550,7 +589,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.")
@@ -596,7 +635,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
@@ -610,7 +649,7 @@ def create_kobo_tag(shelf):
        "Type": "UserTag"
    }
    for book_shelf in shelf.books:
-        book = db.session.query(db.Books).filter(db.Books.id == book_shelf.book_id).one_or_none()
+        book = calibre_db.get_book(book_shelf.book_id)
        if not book:
            log.info(u"Book (id: %s) in BookShelf (id: %s) not found in book database",  book_shelf.book_id, shelf.id)
            continue
@@ -624,9 +663,9 @@ def create_kobo_tag(shelf):


@kobo.route("/v1/library/<book_uuid>/state", methods=["GET", "PUT"])
-@login_required
+@requires_kobo_auth
 def HandleStateRequest(book_uuid):
-    book = db.session.query(db.Books).filter(db.Books.uuid == book_uuid).first()
+    book = calibre_db.get_book_by_uuid(book_uuid)
    if not book or not book.data:
        log.info(u"Book %s not found in database", book_uuid)
        return redirect_or_proxy_request()
@@ -677,7 +716,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],
@@ -715,7 +754,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


@@ -798,10 +837,10 @@ def TopLevelEndpoint():


@kobo.route("/v1/library/<book_uuid>", methods=["DELETE"])
-@login_required
+@requires_kobo_auth
 def HandleBookDeletionRequest(book_uuid):
    log.info("Kobo book deletion request received for book %s" % book_uuid)
-    book = db.session.query(db.Books).filter(db.Books.uuid == book_uuid).first()
+    book = calibre_db.get_book_by_uuid(book_uuid)
    if not book:
        log.info(u"Book %s not found in database", book_uuid)
        return redirect_or_proxy_request()
@@ -818,8 +857,7 @@ def HandleBookDeletionRequest(book_uuid):
    archived_book.last_modified = datetime.datetime.utcnow()

    ub.session.merge(archived_book)
-    ub.session.commit()
-
+    ub.session_commit()
    return ("", 204)


@@ -845,6 +883,7 @@ def HandleUserRequest(dummy=None):
@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/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/dailydeal", methods=["GET", "POST"])
@@ -914,7 +953,7 @@ def HandleInitRequest():
        kobo_resources = NATIVE_KOBO_RESOURCES()

    if not current_app.wsgi_app.is_proxied:
-        log.debug('Kobo: Received unproxied request, changed request port to server port')
+        log.debug('Kobo: Received unproxied request, changed request port to external server port')
        if ':' in request.host and not request.host.endswith(']'):
            host = "".join(request.host.split(':')[:-1])
        else:
@@ -922,8 +961,9 @@ def HandleInitRequest():
        calibre_web_url = "{url_scheme}://{url_base}:{url_port}".format(
            url_scheme=request.scheme,
            url_base=host,
-            url_port=config.config_port
+            url_port=config.config_external_port
        )
+        log.debug('Kobo: Received unproxied request, changed request url to %s', calibre_web_url)
        kobo_resources["image_host"] = calibre_web_url
        kobo_resources["image_url_quality_template"] = unquote(calibre_web_url +
                                                               url_for("kobo.HandleCoverImageRequest",
@@ -932,16 +972,14 @@ def HandleInitRequest():
                                                                       width="{width}",
                                                                       height="{height}",
                                                                       Quality='{Quality}',
-                                                                       isGreyscale='isGreyscale'
-                                                               ))
+                                                                       isGreyscale='isGreyscale'))
        kobo_resources["image_url_template"] = unquote(calibre_web_url +
                                                       url_for("kobo.HandleCoverImageRequest",
                                                               auth_token=kobo_auth.get_auth_token(),
                                                               book_uuid="{ImageId}",
                                                               width="{width}",
                                                               height="{height}",
-                                                               isGreyscale='false'
-                                                       ))
+                                                               isGreyscale='false'))
    else:
        kobo_resources["image_host"] = url_for("web.index", _external=True).strip("/")
        kobo_resources["image_url_quality_template"] = unquote(url_for("kobo.HandleCoverImageRequest",
@@ -960,13 +998,19 @@ def HandleInitRequest():
                                                               isGreyscale='false',
                                                               _external=True))

-
    response = make_response(jsonify({"Resources": kobo_resources}))
    response.headers["x-kobo-apitoken"] = "e30="

    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",
@@ -979,7 +1023,7 @@ def NATIVE_KOBO_RESOURCES():
        "blackstone_header": {"key": "x-amz-request-payer", "value": "requester"},
        "book": "https://storeapi.kobo.com/v1/products/books/{ProductId}",
        "book_detail_page": "https://store.kobobooks.com/{culture}/ebook/{slug}",
-        "book_detail_page_rakuten": "http://books.rakuten.co.jp/rk/{crossrevisionid}",
+        "book_detail_page_rakuten": "https://books.rakuten.co.jp/rk/{crossrevisionid}",
        "book_landing_page": "https://store.kobobooks.com/ebooks",
        "book_subscription": "https://storeapi.kobo.com/v1/products/books/subscriptions",
        "categories": "https://storeapi.kobo.com/v1/categories",
@@ -1017,7 +1061,7 @@ def NATIVE_KOBO_RESOURCES():
        "get_tests_request": "https://storeapi.kobo.com/v1/analytics/gettests",
        "giftcard_epd_redeem_url": "https://www.kobo.com/{storefront}/{language}/redeem-ereader",
        "giftcard_redeem_url": "https://www.kobo.com/{storefront}/{language}/redeem",
-        "help_page": "http://www.kobo.com/help",
+        "help_page": "https://www.kobo.com/help",
        "kobo_audiobooks_enabled": "False",
        "kobo_audiobooks_orange_deal_enabled": "False",
        "kobo_audiobooks_subscriptions_enabled": "False",
@@ -64,11 +64,11 @@ from datetime import datetime
 from os import urandom

 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
+from . import logger, config, calibre_db, db, helper, ub, lm
+from .render_template import render_title_template

 try:
    from functools import wraps
@@ -121,7 +121,11 @@ 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):
-    host = ':'.join(request.host.rsplit(':')[0:-1])
+    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(
@@ -143,7 +147,15 @@ def generate_auth_token(user_id):
            auth_token.token_type = 1

            ub.session.add(auth_token)
-            ub.session.commit()
+            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.nickname)
+
        return render_title_template(
            "generate_kobo_auth_url.html",
            title=_(u"Kobo Setup"),
@@ -160,5 +172,5 @@ def delete_auth_token(user_id):
    # Invalidate any prevously 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()
@@ -41,10 +41,37 @@ logging.addLevelName(logging.WARNING, "WARN")
 logging.addLevelName(logging.CRITICAL, "CRIT")


+class _Logger(logging.Logger):
+
+    def debug_or_exception(self, message, *args, **kwargs):
+        if sys.version_info > (3, 7):
+            if is_debug_enabled():
+                self.exception(message, stacklevel=2, *args, **kwargs)
+            else:
+                self.error(message, stacklevel=2, *args, **kwargs)
+        elif sys.version_info > (3, 0):
+            if is_debug_enabled():
+                self.exception(message, stack_info=True, *args, **kwargs)
+            else:
+                self.error(message, *args, **kwargs)
+        else:
+            if is_debug_enabled():
+                self.exception(message, *args, **kwargs)
+            else:
+                self.error(message, *args, **kwargs)
+
+
+    def debug_no_auth(self, message, *args, **kwargs):
+        if message.startswith("send: AUTH"):
+            self.debug(message[:16], stacklevel=2, *args, **kwargs)
+        else:
+            self.debug(message, stacklevel=2, *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 +81,6 @@ def create():
    parent_module = inspect.getmodule(parent_frame)
    return get(parent_module.__name__)

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

@@ -82,7 +108,6 @@ def _absolute_log_file(log_file, default_log_file):
        if not os.path.dirname(log_file):
            log_file = os.path.join(_CONFIG_DIR, log_file)
        return os.path.abspath(log_file)
-
    return default_log_file


@@ -100,6 +125,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
@@ -115,7 +141,7 @@ def setup(log_file, log_level=None):
    if previous_handler:
        # if the log_file has not changed, don't create a new handler
        if getattr(previous_handler, 'baseFilename', None) == log_file:
-            return
+            return "" if log_file == DEFAULT_LOG_FILE else log_file
        logging.debug("logging to %s level %s", log_file, r.level)

    if log_file == LOG_TO_STDERR or log_file == LOG_TO_STDOUT:
@@ -127,17 +153,19 @@ def setup(log_file, log_level=None):
            file_handler.baseFilename = log_file
    else:
        try:
-            file_handler = RotatingFileHandler(log_file, maxBytes=50000, backupCount=2)
+            file_handler = RotatingFileHandler(log_file, maxBytes=50000, backupCount=2, encoding='utf-8')
        except IOError:
            if log_file == DEFAULT_LOG_FILE:
                raise
-            file_handler = RotatingFileHandler(DEFAULT_LOG_FILE, maxBytes=50000, backupCount=2)
+            file_handler = RotatingFileHandler(DEFAULT_LOG_FILE, maxBytes=50000, backupCount=2, encoding='utf-8')
+            log_file = ""
    file_handler.setFormatter(FORMATTER)

    for h in r.handlers:
        r.removeHandler(h)
        h.close()
    r.addHandler(file_handler)
+    return "" if log_file == DEFAULT_LOG_FILE else log_file


 def create_access_log(log_file, log_name, formatter):
@@ -150,11 +178,18 @@ def create_access_log(log_file, log_name, formatter):
    access_log = logging.getLogger(log_name)
    access_log.propagate = False
    access_log.setLevel(logging.INFO)
+    try:
+        file_handler = RotatingFileHandler(log_file, maxBytes=50000, backupCount=2, encoding='utf-8')
+    except IOError:
+        if log_file == DEFAULT_ACCESS_LOG:
+            raise
+        file_handler = RotatingFileHandler(DEFAULT_ACCESS_LOG, maxBytes=50000, backupCount=2, encoding='utf-8')
+        log_file = ""

-    file_handler = RotatingFileHandler(log_file, maxBytes=50000, backupCount=2)
    file_handler.setFormatter(formatter)
    access_log.addHandler(file_handler)
-    return access_log
+    return access_log, \
+           "" if _absolute_log_file(log_file, DEFAULT_ACCESS_LOG) == DEFAULT_ACCESS_LOG else log_file


 # Enable logging of smtp lib debug output
@@ -40,7 +40,7 @@ try:
        Stores and retrieves OAuth tokens using a relational database through
        the `SQLAlchemy`_ ORM.

-        .. _SQLAlchemy: http://www.sqlalchemy.org/
+        .. _SQLAlchemy: https://www.sqlalchemy.org/
        """
        def __init__(self, model, session, provider_id,
                     user=None, user_id=None, user_required=None, anon_user=None,
@@ -30,11 +30,11 @@ 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 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


@@ -84,11 +84,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.nickname, oauth_key))


 def logout_oauth_user():
@@ -100,16 +96,12 @@ def logout_oauth_user():
 if ub.oauth_support:
    oauthblueprints = []
    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',
@@ -122,10 +114,10 @@ if ub.oauth_support:
    ele2 = dict(provider_name='google',
                id=oauth_ids[1].id,
                active=oauth_ids[1].active,
-                scope=["https://www.googleapis.com/auth/plus.me", "https://www.googleapis.com/auth/userinfo.email"],
+                scope=["https://www.googleapis.com/auth/userinfo.email"],
                oauth_client_id=oauth_ids[1].oauth_client_id,
                oauth_client_secret=oauth_ids[1].oauth_client_secret,
-                obtain_link='https://github.com/settings/developers')
+                obtain_link='https://console.developers.google.com/apis/credentials')
    oauthblueprints.append(ele1)
    oauthblueprints.append(ele2)

@@ -199,12 +191,8 @@ if ub.oauth_support:
                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()
+        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
@@ -235,7 +223,7 @@ if ub.oauth_support:
                        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)
+                        log.debug_or_exception(e)
                        ub.session.rollback()
                else:
                    flash(_(u"Login failed, No User Linked With OAuth Account"), category="error")
@@ -282,12 +270,12 @@ if ub.oauth_support:
                    logout_oauth_user()
                    flash(_(u"Unlink to %(oauth)s Succeeded", oauth=oauth_check[provider]), category="success")
                except Exception as e:
-                    log.exception(e)
+                    log.debug_or_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=oauth_check[provider]), category="error")
+            flash(_(u"Not Linked to %(oauth)s", oauth=provider), category="error")
        return redirect(url_for('web.profile'))


@@ -355,4 +343,4 @@ if ub.oauth_support:
    @oauth.route('/unlink/google', methods=["GET"])
    @login_required
    def google_login_unlink():
-        return unlink_oauth(oauthblueprints[1]['blueprint'].name)
+        return unlink_oauth(oauthblueprints[1]['id'])
@@ -25,15 +25,16 @@ 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 werkzeug.security import check_password_hash

-from . import constants, logger, config, db, ub, services, get_locale, isoLanguages
-from .helper import fill_indexpage, get_download_link, get_book_cover, speaking_language
+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 common_filters, get_search_results, 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
@@ -51,7 +52,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

@@ -100,15 +101,15 @@ def feed_normal_search():
@requires_basic_auth_if_no_ano
 def feed_new():
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books, True, [db.Books.timestamp.desc()])
+    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)


@opds.route("/opds/discover")
@requires_basic_auth_if_no_ano
 def feed_discover():
-    entries = db.session.query(db.Books).filter(common_filters()).order_by(func.random())\
+    entries = calibre_db.session.query(db.Books).filter(calibre_db.common_filters()).order_by(func.random())\
        .limit(config.config_books_per_page)
    pagination = Pagination(1, config.config_books_per_page, int(config.config_books_per_page))
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)
@@ -118,9 +119,9 @@ def feed_discover():
@requires_basic_auth_if_no_ano
 def feed_best_rated():
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books, db.Books.ratings.any(db.Ratings.rating > 9),
-                                             [db.Books.timestamp.desc()])
+    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)


@@ -133,16 +134,13 @@ def feed_hot():
    hot_books = all_books.offset(off).limit(config.config_books_per_page)
    entries = list()
    for book in hot_books:
-        downloadBook = db.session.query(db.Books).filter(db.Books.id == book.Downloads.book_id).first()
+        downloadBook = calibre_db.get_book(book.Downloads.book_id)
        if downloadBook:
            entries.append(
-                db.session.query(db.Books).filter(common_filters())
-                .filter(db.Books.id == book.Downloads.book_id).first()
+                calibre_db.get_filtered_book(book.Downloads.book_id)
            )
        else:
            ub.delete_download(book.Downloads.book_id)
-            # ub.session.query(ub.Downloads).filter(book.Downloads.book_id == ub.Downloads.book_id).delete()
-            # ub.session.commit()
    numBooks = entries.__len__()
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1),
                            config.config_books_per_page, numBooks)
@@ -153,11 +151,13 @@ def feed_hot():
@requires_basic_auth_if_no_ano
 def feed_authorindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Authors).join(db.books_authors_link).join(db.Books).filter(common_filters())\
-        .group_by(text('books_authors_link.author')).order_by(db.Authors.sort).limit(config.config_books_per_page)\
+    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)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(db.session.query(db.Authors).all()))
+                            len(calibre_db.session.query(db.Authors).all()))
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_author', pagination=pagination)


@@ -165,10 +165,10 @@ def feed_authorindex():
@requires_basic_auth_if_no_ano
 def feed_author(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.authors.any(db.Authors.id == book_id),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -176,11 +176,14 @@ def feed_author(book_id):
@requires_basic_auth_if_no_ano
 def feed_publisherindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Publishers).join(db.books_publishers_link).join(db.Books).filter(common_filters())\
-        .group_by(text('books_publishers_link.publisher')).order_by(db.Publishers.sort)\
+    entries = calibre_db.session.query(db.Publishers)\
+        .join(db.books_publishers_link)\
+        .join(db.Books).filter(calibre_db.common_filters())\
+        .group_by(text('books_publishers_link.publisher'))\
+        .order_by(db.Publishers.sort)\
        .limit(config.config_books_per_page).offset(off)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(db.session.query(db.Publishers).all()))
+                            len(calibre_db.session.query(db.Publishers).all()))
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_publisher', pagination=pagination)


@@ -188,10 +191,10 @@ def feed_publisherindex():
@requires_basic_auth_if_no_ano
 def feed_publisher(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.publishers.any(db.Publishers.id == book_id),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -199,10 +202,16 @@ def feed_publisher(book_id):
@requires_basic_auth_if_no_ano
 def feed_categoryindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Tags).join(db.books_tags_link).join(db.Books).filter(common_filters())\
-        .group_by(text('books_tags_link.tag')).order_by(db.Tags.name).offset(off).limit(config.config_books_per_page)
+    entries = calibre_db.session.query(db.Tags)\
+        .join(db.books_tags_link)\
+        .join(db.Books)\
+        .filter(calibre_db.common_filters())\
+        .group_by(text('books_tags_link.tag'))\
+        .order_by(db.Tags.name)\
+        .offset(off)\
+        .limit(config.config_books_per_page)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(db.session.query(db.Tags).all()))
+                            len(calibre_db.session.query(db.Tags).all()))
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_category', pagination=pagination)


@@ -210,10 +219,10 @@ def feed_categoryindex():
@requires_basic_auth_if_no_ano
 def feed_category(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.tags.any(db.Tags.id == book_id),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -221,10 +230,15 @@ def feed_category(book_id):
@requires_basic_auth_if_no_ano
 def feed_seriesindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Series).join(db.books_series_link).join(db.Books).filter(common_filters())\
-        .group_by(text('books_series_link.series')).order_by(db.Series.sort).offset(off).all()
+    entries = calibre_db.session.query(db.Series)\
+        .join(db.books_series_link)\
+        .join(db.Books)\
+        .filter(calibre_db.common_filters())\
+        .group_by(text('books_series_link.series'))\
+        .order_by(db.Series.sort)\
+        .offset(off).all()
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
-                            len(db.session.query(db.Series).all()))
+                            len(calibre_db.session.query(db.Series).all()))
    return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_series', pagination=pagination)


@@ -232,10 +246,10 @@ def feed_seriesindex():
@requires_basic_auth_if_no_ano
 def feed_series(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.series.any(db.Series.id == book_id),
-                                             [db.Books.series_index])
+    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])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -243,10 +257,13 @@ def feed_series(book_id):
@requires_basic_auth_if_no_ano
 def feed_ratingindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Ratings, func.count('books_ratings_link.book').label('count'),
+    entries = calibre_db.session.query(db.Ratings, func.count('books_ratings_link.book').label('count'),
                               (db.Ratings.rating / 2).label('name')) \
-        .join(db.books_ratings_link).join(db.Books).filter(common_filters()) \
-        .group_by(text('books_ratings_link.rating')).order_by(db.Ratings.rating).all()
+        .join(db.books_ratings_link)\
+        .join(db.Books)\
+        .filter(calibre_db.common_filters()) \
+        .group_by(text('books_ratings_link.rating'))\
+        .order_by(db.Ratings.rating).all()

    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
                            len(entries))
@@ -260,10 +277,10 @@ def feed_ratingindex():
@requires_basic_auth_if_no_ano
 def feed_ratings(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.ratings.any(db.Ratings.id == book_id),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -271,8 +288,10 @@ def feed_ratings(book_id):
@requires_basic_auth_if_no_ano
 def feed_formatindex():
    off = request.args.get("offset") or 0
-    entries = db.session.query(db.Data).join(db.Books).filter(common_filters()) \
-        .group_by(db.Data.format).order_by(db.Data.format).all()
+    entries = calibre_db.session.query(db.Data).join(db.Books)\
+        .filter(calibre_db.common_filters()) \
+        .group_by(db.Data.format)\
+        .order_by(db.Data.format).all()
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
                            len(entries))

@@ -286,10 +305,10 @@ def feed_formatindex():
@requires_basic_auth_if_no_ano
 def feed_format(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.data.any(db.Data.format == book_id.upper()),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -299,13 +318,13 @@ def feed_format(book_id):
 def feed_languagesindex():
    off = request.args.get("offset") or 0
    if current_user.filter_language() == u"all":
-        languages = speaking_language()
+        languages = calibre_db.speaking_language()
    else:
        try:
            cur_l = LC.parse(current_user.filter_language())
        except UnknownLocaleError:
            cur_l = None
-        languages = db.session.query(db.Languages).filter(
+        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())
@@ -320,10 +339,10 @@ def feed_languagesindex():
@requires_basic_auth_if_no_ano
 def feed_languages(book_id):
    off = request.args.get("offset") or 0
-    entries, __, pagination = fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1),
-                                             db.Books,
-                                             db.Books.languages.any(db.Languages.id == book_id),
-                                             [db.Books.timestamp.desc()])
+    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()])
    return render_xml_template('feed.xml', entries=entries, pagination=pagination)


@@ -356,7 +375,7 @@ def feed_shelf(book_id):
        books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == book_id).order_by(
            ub.BookShelf.order.asc()).all()
        for book in books_in_shelf:
-            cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
+            cur_book = calibre_db.get_book(book.book_id)
            result.append(cur_book)
    pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
                            len(result))
@@ -365,16 +384,25 @@ 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):
-    return get_download_link(book_id, book_format.lower())
+    # 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:
+        client = ""
+    return get_download_link(book_id, book_format.lower(), client)


@opds.route("/ajax/book/<string:uuid>/<library>")
@opds.route("/ajax/book/<string:uuid>", defaults={'library': ""})
@requires_basic_auth_if_no_ano
 def get_metadata_calibre_companion(uuid, library):
-    entry = db.session.query(db.Books).filter(db.Books.uuid.like("%" + uuid + "%")).first()
+    entry = calibre_db.session.query(db.Books).filter(db.Books.uuid.like("%" + uuid + "%")).first()
    if entry is not None:
        js = render_template('json.txt', entry=entry)
        response = make_response(js)
@@ -386,8 +414,7 @@ def get_metadata_calibre_companion(uuid, library):

 def feed_search(term):
    if term:
-        term = term.strip().lower()
-        entries = 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)
@@ -397,10 +424,18 @@ def feed_search(term):

 def check_auth(username, password):
    if sys.version_info.major == 3:
-        username = username.encode('windows-1252')
+        try:
+            username = username.encode('windows-1252')
+        except UnicodeEncodeError:
+            username = username.encode('utf-8')
    user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) ==
                                            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:
+        ipAdress = request.headers.get('X-Forwarded-For', request.remote_addr)
+        log.warning('OPDS Login failed for user "%s" IP-address: %s', username.decode('utf-8'), ipAdress)
+        return False


 def authenticate():
@@ -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.nickname))
+
+        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.nickname), 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,116 @@
+# -*- 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})
+    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)
@@ -77,6 +77,7 @@ class ReverseProxied(object):
        servr = environ.get('HTTP_X_FORWARDED_HOST', '')
        if servr:
            environ['HTTP_HOST'] = servr
+            self.proxied = True
        return self.app(environ, start_response)

    @property
@@ -27,6 +27,8 @@ 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:
@@ -72,7 +74,11 @@ class WebServer(object):
        if config.config_access_log:
            log_name = "gevent.access" if _GEVENT else "tornado.access"
            formatter = logger.ACCESS_FORMATTER_GEVENT if _GEVENT else logger.ACCESS_FORMATTER_TORNADO
-            self.access_logger = logger.create_access_log(config.config_access_logfile, log_name, formatter)
+            self.access_logger, logfile = logger.create_access_log(config.config_access_logfile, log_name, formatter)
+            if logfile != config.config_access_logfile:
+                log.warning("Accesslog path %s not valid, falling back to default", config.config_access_logfile)
+                config.config_access_logfile = logfile
+                config.save()
        else:
            if not _GEVENT:
                logger.get('tornado.access').disabled = True
@@ -139,6 +145,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:
@@ -190,7 +206,7 @@ class WebServer(object):
        os.execv(sys.executable, arguments)
        return True

-    def _killServer(self, ignored_signum, ignored_frame):
+    def _killServer(self, __, ___):
        self.stop()

    def stop(self, restart=False):
@@ -27,7 +27,10 @@ except ImportError:
    from urllib.parse import unquote

 from flask import json
-from .. import logger as log
+from .. import logger
+
+
+log = logger.create()


 def b64encode_json(json_data):
@@ -45,7 +48,8 @@ def to_epoch_timestamp(datetime_object):
 def get_datetime_from_json(json_object, field_name):
    try:
        return datetime.utcfromtimestamp(json_object[field_name])
-    except KeyError:
+    except (KeyError, OSError, OverflowError):
+        # OSError is thrown on Windows if timestamp is <1970 or >2038
        return datetime.min


@@ -81,6 +85,7 @@ class SyncToken:
            "archive_last_modified": {"type": "string"},
            "reading_state_last_modified": {"type": "string"},
            "tags_last_modified": {"type": "string"},
+            "books_last_id": {"type": "integer", "optional": True}
        },
    }

@@ -92,6 +97,7 @@ class SyncToken:
        archive_last_modified=datetime.min,
        reading_state_last_modified=datetime.min,
        tags_last_modified=datetime.min,
+        books_last_id=-1
    ):
        self.raw_kobo_store_token = raw_kobo_store_token
        self.books_last_created = books_last_created
@@ -99,6 +105,7 @@ class SyncToken:
        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):
@@ -133,9 +140,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,
@@ -143,7 +153,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):
@@ -166,7 +177,8 @@ 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)
@@ -20,7 +20,10 @@ from __future__ import division, print_function, unicode_literals
 import time
 from functools import reduce

-from goodreads.client import GoodreadsClient
+try:
+    from goodreads.client import GoodreadsClient
+except ImportError:
+    from betterreads.client import GoodreadsClient

 try: import Levenshtein
 except ImportError: Levenshtein = False
@@ -69,7 +72,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:
@@ -95,8 +98,12 @@ def get_other_books(author_info, library_books=None):
    for book in author_info.books:
        if book.isbn in identifiers:
            continue
-        if book.gid["#text"] in identifiers:
-            continue
+        if isinstance(book.gid, int):
+            if book.gid in identifiers:
+                continue
+        else:
+            if book.gid["#text"] in identifiers:
+                continue

        if Levenshtein and library_titles:
            goodreads_title = book._book_dict['title_without_series']
@@ -20,7 +20,7 @@ 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 +38,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 +55,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

@@ -64,13 +71,22 @@ def init_app(app, config):
    app.config['LDAP_OPENLDAP'] = bool(config.config_ldap_openldap)
    app.config['LDAP_GROUP_OBJECT_FILTER'] = config.config_ldap_group_object_filter
    app.config['LDAP_GROUP_MEMBERS_FIELD'] = config.config_ldap_group_members_field
-    # app.config['LDAP_CUSTOM_OPTIONS'] = {'OPT_NETWORK_TIMEOUT': 10}

-    _ldap.init_app(app)
+    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():
@@ -101,7 +117,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,219 @@
+
+from __future__ import division, print_function, unicode_literals
+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
+        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 e:
+            self._handleError(str(e))
+            log.debug_or_exception(e)
+
+        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):
+        # todo: throw error if outside of [0,1]
+        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
@@ -22,15 +22,17 @@

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

 from flask import Blueprint, request, flash, redirect, url_for
 from flask_babel import gettext as _
 from flask_login import login_required, current_user
-from sqlalchemy.sql.expression import func
+from sqlalchemy.sql.expression import func, true
+from sqlalchemy.exc import OperationalError, InvalidRequestError

-from . import logger, ub, searched_ids, db
-from .web import render_title_template
-from .helper import common_filters
+from . import logger, ub, calibre_db, db
+from .render_template import render_title_template
+from .usermanagement import login_required_if_no_ano


 shelf = Blueprint('shelf', __name__)
@@ -92,8 +94,16 @@ def add_to_shelf(shelf_id, book_id):

    shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1))
    shelf.last_modified = datetime.utcnow()
-    ub.session.merge(shelf)
-    ub.session.commit()
+    try:
+        ub.session.merge(shelf)
+        ub.session.commit()
+    except (OperationalError, InvalidRequestError):
+        ub.session.rollback()
+        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:
        flash(_(u"Book has been added to shelf: %(sname)s", sname=shelf.name), category="success")
        if "HTTP_REFERER" in request.environ:
@@ -116,37 +126,37 @@ def search_to_shelf(shelf_id):
        flash(_(u"You are not allowed to add a book to the the shelf: %(name)s", name=shelf.name), 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 %s", 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()
-        ub.session.merge(shelf)
-        ub.session.commit()
-        flash(_(u"Books have been added to shelf: %(sname)s", sname=shelf.name), category="success")
+        try:
+            ub.session.merge(shelf)
+            ub.session.commit()
+            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")
    else:
        flash(_(u"Could not add books to shelf: %(sname)s", sname=shelf.name), category="error")
    return redirect(url_for('web.index'))
@@ -181,10 +191,17 @@ def remove_from_shelf(shelf_id, book_id):
                return redirect(url_for('web.index'))
            return "Book already removed from shelf", 410

-        ub.session.delete(book_shelf)
-        shelf.last_modified = datetime.utcnow()
-        ub.session.commit()
-
+        try:
+            ub.session.delete(book_shelf)
+            shelf.last_modified = datetime.utcnow()
+            ub.session.commit()
+        except (OperationalError, InvalidRequestError):
+            ub.session.rollback()
+            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:
            flash(_(u"Book has been removed from shelf: %(sname)s", sname=shelf.name), category="success")
            if "HTTP_REFERER" in request.environ:
@@ -204,88 +221,76 @@ def remove_from_shelf(shelf_id, book_id):
@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)
-
-        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 Exception:
-                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")
+    return create_edit_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()
+    return create_edit_shelf(shelf, 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, title, page, shelf_id=False):
    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")
+        if "is_public" in to_save:
+            shelf.is_public = 1
        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.is_public = 0
+        if check_shelf_is_unique(shelf, to_save, shelf_id):
            shelf.name = to_save["title"]
-            shelf.last_modified = datetime.utcnow()
-            if "is_public" in to_save:
-                shelf.is_public = 1
+            # shelf.last_modified = datetime.utcnow()
+            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=to_save["title"])
            else:
-                shelf.is_public = 0
+                shelf_action = "changed"
+                flash_text = _(u"Shelf %(title)s changed", title=to_save["title"])
            try:
                ub.session.commit()
-                flash(_(u"Shelf %(title)s changed", title=to_save["title"]), category="success")
-            except Exception:
+                log.info(u"Shelf {} {}".format(to_save["title"], shelf_action))
+                flash(flash_text, category="success")
+                return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id))
+            except (OperationalError, InvalidRequestError) as e:
+                ub.session.rollback()
+                log.debug_or_exception(e)
+                flash(_(u"Settings DB is not Writeable"), category="error")
+            except Exception as e:
+                ub.session.rollback()
+                log.debug_or_exception(e)
                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=title, page=page)
+
+
+def check_shelf_is_unique(shelf, to_save, 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 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(ident) \
+                                   .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(ident) \
+                                   .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")
+    return is_shelf_name_unique


 def delete_shelf_helper(cur_shelf):
@@ -295,45 +300,33 @@ 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>")
@login_required
 def delete_shelf(shelf_id):
    cur_shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
-    delete_shelf_helper(cur_shelf)
+    try:
+        delete_shelf_helper(cur_shelf)
+    except InvalidRequestError:
+        ub.session.rollback()
+        flash(_(u"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>")
-def show_shelf(shelf_type, shelf_id):
-    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
+@shelf.route("/simpleshelf/<int:shelf_id>")
+@login_required_if_no_ano
+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 = db.session.query(db.Books).filter(db.Books.id == book.book_id).filter(common_filters()).first()
-            if cur_book:
-                result.append(cur_book)
-            else:
-                cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
-                if not cur_book:
-                    log.info('Not existing book %s in %s deleted', book.book_id, shelf)
-                    ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == book.book_id).delete()
-                    ub.session.commit()
-        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"])
@@ -348,27 +341,88 @@ def order_shelf(shelf_id):
            setattr(book, 'order', to_save[str(book.book_id)])
            counter += 1
            # if order diffrent from before -> shelf.last_modified = datetime.utcnow()
-        ub.session.commit()
+        try:
+            ub.session.commit()
+        except (OperationalError, InvalidRequestError):
+            ub.session.rollback()
+            flash(_(u"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 = db.session.query(db.Books).filter(db.Books.id == book.book_id).filter(common_filters()).first()
-            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 = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
-                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).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()])
+            if sort_param == 'authza':
+                change_shelf_order(shelf_id, [db.Books.author_sort.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()
+                flash(_(u"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"))
@@ -0,0 +1,22 @@
+body.serieslist.grid-view div.container-fluid>div>div.col-sm-10:before{
+    display: none;
+}
+.cover .badge{
+    position: absolute;
+    top: 0;
+    left: 0;
+    color: #fff;
+    background-color: #cc7b19;
+    border-radius: 0;
+    padding: 0 8px;
+    box-shadow: 0 0 4px rgba(0,0,0,.6);
+    line-height: 24px;
+}
+.cover{
+    box-shadow: 0 0 4px rgba(0,0,0,.6);
+}
+
+.cover .read{
+    padding: 0 0px;
+    line-height: 15px;
+}
@@ -25,10 +25,9 @@ body {
  overflow: hidden;
  -webkit-transition: -webkit-transform 0.4s, width 0.2s;
  -moz-transition: -webkit-transform 0.4s, width 0.2s;
-  -ms-transition: -webkit-transform 0.4s, width 0.2s;
+  transition: -webkit-transform 0.4s, width 0.2s;
  -moz-box-shadow: inset 0 0 50px rgba(0, 0, 0, 0.1);
  -webkit-box-shadow: inset 0 0 50px rgba(0, 0, 0, 0.1);
-  -ms-box-shadow: inset 0 0 50px rgba(0, 0, 0, 0.1);
  box-shadow: inset 0 0 50px rgba(0, 0, 0, 0.1);
 }

@@ -45,7 +44,7 @@ body {
  text-align: center;
  -webkit-transition: opacity 0.5s;
  -moz-transition: opacity 0.5s;
-  -ms-transition: opacity 0.5s;
+  transition: opacity 0.5s;
  z-index: 10;
 }

@@ -79,7 +78,6 @@ body {
  color: rgba(0, 0, 0, 0.6);
  -moz-box-shadow: inset 0 0 6px rgba(155, 155, 155, 0.8);
  -webkit-box-shadow: inset 0 0 6px rgba(155, 155, 155, 0.8);
-  -ms-box-shadow: inset 0 0 6px rgba(155, 155, 155, 0.8);
  box-shadow: inset 0 0 6px rgba(155, 155, 155, 0.8);
 }

@@ -121,7 +119,6 @@ body {
  font-weight: bold;
  cursor: pointer;
  -webkit-user-select: none;
-  -khtml-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
@@ -147,7 +144,7 @@ body {
  height: 100%;
  -webkit-transition: -webkit-transform 0.5s;
  -moz-transition: -moz-transform 0.5s;
-  -ms-transition: -moz-transform 0.5s;
+  transition: -moz-transform 0.5s;
  overflow: hidden;
 }

@@ -183,7 +180,6 @@ body {
  height: 14px;
  -moz-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
  -webkit-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
-  -ms-box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.6);
 }

@@ -232,7 +228,6 @@ body {

 input::-webkit-input-placeholder { color: #454545; }
 input:-moz-placeholder { color: #454545; }
-input:-ms-placeholder { color: #454545; }

 #divider {
  position: absolute;
@@ -268,18 +263,18 @@ input:-ms-placeholder { color: #454545; }
  width: 25%;
  height: 100%;
  visibility: hidden;
-  -webkit-transition: visibility 0 ease 0.5s;
-  -moz-transition: visibility 0 ease 0.5s;
-  -ms-transition: visibility 0 ease 0.5s;
+  -webkit-transition: visibility 0s ease 0.5s;
+  -moz-transition: visibility 0s ease 0.5s;
+  transition: visibility 0s ease 0.5s;
 }

 #sidebar.open #tocView,
 #sidebar.open #bookmarksView {
  overflow-y: auto;
  visibility: visible;
-  -webkit-transition: visibility 0 ease 0;
-  -moz-transition: visibility 0 ease 0;
-  -ms-transition: visibility 0 ease 0;
+  -webkit-transition: visibility 0s ease 0s;
+  -moz-transition: visibility 0s ease 0s;
+  transition: visibility 0s ease 0s;
 }

 #sidebar.open #tocView {
@@ -495,9 +490,8 @@ input:-ms-placeholder { color: #454545; }
  position: fixed;
  top: 50%;
  left: 50%;
-  width: 50%;
+  // width: 50%;
  width: 630px;
-
  height: auto;
  z-index: 2000;
  visibility: hidden;
@@ -518,7 +512,6 @@ input:-ms-placeholder { color: #454545; }
  background: rgba(255, 255, 255, 0.8);
  -webkit-transition: all 0.3s;
  -moz-transition: all 0.3s;
-  -ms-transition: all 0.3s;
  transition: all 0.3s;
 }

@@ -588,7 +581,6 @@ input:-ms-placeholder { color: #454545; }
  opacity: 0;
  -webkit-transition: all 0.3s;
  -moz-transition: all 0.3s;
-  -ms-transition: all 0.3s;
  transition: all 0.3s;
 }

@@ -601,7 +593,7 @@ input:-ms-placeholder { color: #454545; }
 }

 .md-content > .closer {
-  font-size: 18px;
+  //font-size: 18px;
  position: absolute;
  right: 0;
  top: 0;
@@ -663,7 +655,7 @@ input:-ms-placeholder { color: #454545; }
    -ms-transform: translate(0, 0);
    -webkit-transition: -webkit-transform .3s;
    -moz-transition: -moz-transform .3s;
-    -ms-transition: -moz-transform .3s;
+    transition: -moz-transform .3s;
  }

  #main.closed {
@@ -778,7 +770,7 @@ and (orientation : landscape)
 }

 [class^="icon-"]:before, [class*=" icon-"]:before {
-    font-family: "fontello";
+    font-family: "fontello", serif;
    font-style: normal;
    font-weight: normal;
    speak: none;
@@ -51,7 +51,22 @@ body h2 {
  color:#444;
 }

-a { color: #45b29d; }
+a, .danger,.book-remove, .editable-empty, .editable-empty:hover { color: #45b29d; }
+
+.book-remove:hover { color: #23527c; }
+
+.btn-default a { color: #444; }
+
+.btn-default a:hover {
+    color: #45b29d;
+    text-decoration: None;
+}
+
+.btn-default:hover {
+    color: #45b29d;
+}
+
+.editable-click, a.editable-click, a.editable-click:hover  { border-bottom: None; }

 .navigation .nav-head {
  text-transform: uppercase;
@@ -63,6 +78,7 @@ a { color: #45b29d; }
  border-top: 1px solid #ccc;
  padding-top: 20px;
 }
+
 .navigation li a {
  color: #444;
  text-decoration: none;
@@ -91,28 +107,45 @@ a { color: #45b29d; }
  text-decoration: none;
 }

+.row.display-flex {
+  display: flex;
+  flex-wrap: wrap;
+}
+
 .container-fluid img {
  display: block;
  max-width: 100%;
  height: auto;
+  max-height: 100%;
 }

 .container-fluid .discover{ margin-bottom: 50px; }
 .container-fluid .new-books { border-top: 1px solid #ccc; }
 .container-fluid .new-books h2 { margin: 50px 0 0 0; }
-.container-fluid .book { margin-top: 20px; }
+.container-fluid .book {
+  margin-top: 20px;
+  display: flex;
+  flex-direction: column;
+}

 .container-fluid .book .cover {
  height: 225px;
  position: relative;
 }

-.container-fluid .book .cover img {
-  border: 1px solid #fff;
-  box-sizeing: border-box;
-  height: 100%;
+.container-fluid .book .cover span.img {
  bottom: 0;
+  height: 100%;
  position: absolute;
+}
+
+.container-fluid .book .cover span img {
+  position: relative;
+  top: 0;
+  left: 0;
+  height: 100%;
+  border: 1px solid #fff;
+  box-sizing: border-box;
  -webkit-box-shadow: 0 5px 8px -6px #777;
  -moz-box-shadow: 0 5px 8px -6px #777;
  box-shadow: 0 5px 8px -6px #777;
@@ -127,14 +160,21 @@ a { color: #45b29d; }
  color: #444;
 }

+.container-fluid .book .meta .series {
+  font-weight: 400;
+  font-size: 12px;
+  color: #444;
+}
+
 .container-fluid .book .meta .author {
  font-size: 12px;
  color: #999;
 }

 .container-fluid .book .meta .rating { margin-top: 5px; }
-.rating .glyphicon-star { color: #999; }
-.rating .glyphicon-star.good { color: #45b29d; }
+.rating .glyphicon-star-empty { color: #444; }
+.rating .glyphicon-star.good { color: #444; }
+.rating-clear .glyphicon-remove { color: #333  }

 .container-fluid .author .author-hidden, .container-fluid .author .author-hidden-divider { display: none; }

@@ -165,7 +205,7 @@ span.glyphicon.glyphicon-tags {

 .container-fluid .single .cover img {
  border: 1px solid #fff;
-  box-sizeing: border-box;
+  box-sizing: border-box;
  -webkit-box-shadow: 0 5px 8px -6px #777;
  -moz-box-shadow: 0 5px 8px -6px #777;
  box-shadow: 0 5px 8px -6px #777;
@@ -174,6 +214,23 @@ span.glyphicon.glyphicon-tags {
 .navbar-default .navbar-toggle .icon-bar {background-color: #000; }
 .navbar-default .navbar-toggle {border-color: #000; }
 .cover { margin-bottom: 10px; }
+
+.cover .badge{
+   position: absolute;
+   top: 2px;
+   left: 2px;
+   color: #000;
+   border-radius: 10px;
+   background-color: #fff;
+}
+.cover .read{
+  left: auto;
+  right: 2px;
+  width: 17px;
+  height: 17px;
+  display: inline-block;
+  padding: 2px;
+}
 .cover-height { max-height: 100px;}

 .col-sm-2 a .cover-small {
@@ -203,11 +260,11 @@ span.glyphicon.glyphicon-tags {
 .button-link {color: #fff; }
 .btn-primary:hover, .btn-primary:focus, .btn-primary:active, .btn-primary.active, .open .dropdown-toggle.btn-primary{ background-color: #1C5484; }
 .btn-primary.disabled, .btn-primary[disabled], fieldset[disabled] .btn-primary, .btn-primary.disabled:hover, .btn-primary[disabled]:hover, fieldset[disabled] .btn-primary:hover, .btn-primary.disabled:focus, .btn-primary[disabled]:focus, fieldset[disabled] .btn-primary:focus, .btn-primary.disabled:active, .btn-primary[disabled]:active, fieldset[disabled] .btn-primary:active, .btn-primary.disabled.active, .btn-primary[disabled].active, fieldset[disabled] .btn-primary.active { background-color: #89B9E2; }
-.btn-toolbar>.btn+.btn, .btn-toolbar>.btn-group+.btn, .btn-toolbar>.btn+.btn-group, .btn-toolbar>.btn-group+.btn-group { margin-left: 0px; }
+.btn-toolbar>.btn+.btn, .btn-toolbar>.btn-group+.btn, .btn-toolbar>.btn+.btn-group, .btn-toolbar>.btn-group+.btn-group { margin-left: 0; }
 .panel-body {background-color: #f5f5f5; }
 .spinner {margin: 0 41%; }
 .spinner2 {margin: 0 41%; }
-
+.intend-form { margin-left:20px; }
 table .bg-dark-danger {background-color: #d9534f; color: #fff; }
 table .bg-dark-danger a {color: #fff; }
 table .bg-dark-danger:hover {background-color: #c9302c; }
@@ -273,13 +330,14 @@ input.pill:not(:checked) + label .glyphicon { display: none; }
 .editable-input { display:inline-block; }

 .editable-cancel {
-  margin-bottom: 0px !important;
+  margin-bottom: 0 !important;
  margin-left: 7px !important;
 }

-.editable-submit { margin-bottom: 0px !important; }
+.editable-submit { margin-bottom: 0 !important; }
 .filterheader { margin-bottom: 20px; }
 .errorlink { margin-top: 20px; }
+.emailconfig { margin-top: 10px; }

 .modal-body .comments {
  max-height: 300px;
@@ -287,7 +345,7 @@ input.pill:not(:checked) + label .glyphicon { display: none; }
 }

 div.log {
-  font-family: Courier New;
+  font-family: Courier New, serif;
  font-size: 12px;
  box-sizing: border-box;
  height: 700px;
@@ -296,3 +354,4 @@ div.log {
  white-space: nowrap;
  padding: 0.5em;
 }
+
@@ -78,10 +78,10 @@ function prefixedSource(prefix, query, cb, bhAdapter) {
    });
 }

-function getPath() {
+/*function getPath() {
    var jsFileLocation = $("script[src*=edit_books]").attr("src");  // the js file path
    return jsFileLocation.substr(0, jsFileLocation.search("/static/js/edit_books.js"));   // the js folder path
-}
+}*/

 var authors = new Bloodhound({
    name: "authors",
@@ -249,18 +249,26 @@ promisePublishers.done(function() {
    );
 });

-$("#search").on("change input.typeahead:selected", function() {
+$("#search").on("change input.typeahead:selected", function(event) {
+    if (event.target.type == "search" && event.target.tagName == "INPUT") {
+        return;
+    }
    var form = $("form").serialize();
    $.getJSON( getPath() + "/get_matching_tags", form, function( data ) {
        $(".tags_click").each(function() {
-            if ($.inArray(parseInt($(this).children("input").first().val(), 10), data.tags) === -1 ) {
-                if (!($(this).hasClass("active"))) {
-                    $(this).addClass("disabled");
+            if ($.inArray(parseInt($(this).val(), 10), data.tags) === -1) {
+                if(!$(this).prop("selected")) {
+                    $(this).prop("disabled", true);
                }
            } else {
-                $(this).removeClass("disabled");
+                $(this).prop("disabled", false);
            }
        });
+        $("#include_tag option:selected").each(function () {
+            $("#exclude_tag").find("[value="+$(this).val()+"]").prop("disabled", true);
+        });
+        $('#include_tag').selectpicker("refresh");
+        $('#exclude_tag').selectpicker("refresh");
    });
 });

@@ -0,0 +1,70 @@
+/* This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+ *    Copyright (C) 2018 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/>.
+ */
+
+var $list = $("#list").isotope({
+    itemSelector: ".book",
+    layoutMode: "fitRows",
+    getSortData: {
+        title: ".title",
+    }
+});
+
+$("#desc").click(function() {
+    var page = $(this).data("id");
+    $.ajax({
+        method:"post",
+        contentType: "application/json; charset=utf-8",
+        dataType: "json",
+        url: window.location.pathname + "/../../ajax/view",
+        data: "{\"" + page + "\": {\"dir\": \"desc\"}}",
+    });
+    $list.isotope({
+        sortBy: "name",
+        sortAscending: true
+    });
+    return;
+});
+
+$("#asc").click(function() {
+    var page = $(this).data("id");
+    $.ajax({
+        method:"post",
+        contentType: "application/json; charset=utf-8",
+        dataType: "json",
+        url: window.location.pathname + "/../../ajax/view",
+        data: "{\"" + page + "\": {\"dir\": \"asc\"}}",
+    });
+    $list.isotope({
+        sortBy: "name",
+        sortAscending: false
+    });
+    return;
+});
+
+$("#all").click(function() {
+    // go through all elements and make them visible
+    $list.isotope({ filter: function() {
+        return true;
+      } })
+});
+
+$(".char").click(function() {
+    var character = this.innerText;
+    $list.isotope({ filter: function() {
+        return this.attributes["data-id"].value.charAt(0).toUpperCase() == character;
+      } })
+});
@@ -19,6 +19,10 @@ var direction = 0;  // Descending order
 var sort = 0;       // Show sorted entries

 $("#sort_name").click(function() {
+    var className = $("h1").attr("Class") + "_sort_name";
+    var obj = {};
+    obj[className] = sort;
+
    var count = 0;
    var index = 0;
    var store;
@@ -40,9 +44,7 @@ $("#sort_name").click(function() {
            count++;
        }
    });
-    /*listItems.sort(function(a,b){
-        return $(a).children()[1].innerText.localeCompare($(b).children()[1].innerText)
-    });*/
+
    // Find count of middle element
    if (count > 20) {
        var middle = parseInt(count / 2, 10) + (count % 2);
@@ -66,6 +68,14 @@ $("#desc").click(function() {
    if (direction === 0) {
        return;
    }
+    var page = $(this).data("id");
+    $.ajax({
+        method:"post",
+        contentType: "application/json; charset=utf-8",
+        dataType: "json",
+        url: window.location.pathname + "/../../ajax/view",
+        data: "{\"" + page + "\": {\"dir\": \"desc\"}}",
+    });
    var index = 0;
    var list = $("#list");
    var second = $("#second");
@@ -102,9 +112,18 @@ $("#desc").click(function() {


 $("#asc").click(function() {
+
    if (direction === 1) {
        return;
    }
+    var page = $(this).data("id");
+    $.ajax({
+        method:"post",
+        contentType: "application/json; charset=utf-8",
+        dataType: "json",
+        url: window.location.pathname + "/../../ajax/view",
+        data: "{\"" + page + "\": {\"dir\": \"asc\"}}",
+    });
    var index = 0;
    var list = $("#list");
    var second = $("#second");
@@ -131,7 +150,6 @@ $("#asc").click(function() {
        });

        // middle = parseInt(elementLength / 2) + (elementLength % 2);
-
        list.append(reversed.slice(0, index));
        second.append(reversed.slice(index, elementLength));
    } else {
@@ -74,8 +74,8 @@ $(function () {
            $("#meta-info").html("<ul id=\"book-list\" class=\"media-list\"></ul>");
        }
        if ((ggDone === 3 || (ggDone === 1 && ggResults.length === 0)) &&
-            (dbDone === 3 || (ggDone === 1 && dbResults.length === 0)) &&
-            (cvDone === 3 || (ggDone === 1 && cvResults.length === 0))) {
+            (dbDone === 3 || (dbDone === 1 && dbResults.length === 0)) &&
+            (cvDone === 3 || (cvDone === 1 && cvResults.length === 0))) {
            $("#meta-info").html("<p class=\"text-danger\">" + msg.no_result + "</p>");
            return;
        }
@@ -108,7 +108,7 @@ $(function () {
                        tags: result.volumeInfo.categories || [],
                        rating: result.volumeInfo.averageRating || 0,
                        cover: result.volumeInfo.imageLinks ?
-                            result.volumeInfo.imageLinks.thumbnail : "/static/generic_cover.jpg",
+                            result.volumeInfo.imageLinks.thumbnail : location + "/../../../static/generic_cover.jpg",
                        url: "https://books.google.com/books?id=" + result.id,
                        source: {
                            id: "google",
@@ -253,7 +253,7 @@ $(function () {
    }

    function dbSearchBook (title) {
-        var apikey = "0df993c66c0c636e29ecbb5344252a4a";
+        var apikey = "054022eaeae0b00e0fc068c0c0a2102a";
        $.ajax({
            url: douban + dbSearch + "?apikey=" + apikey + "&q=" + title + "&fields=all&count=10",
            type: "GET",
@@ -141,9 +141,24 @@ var createURLFromArray = function(array, mimeType) {
 kthoom.ImageFile = function(file) {
    this.filename = file.filename;
    var fileExtension = file.filename.split(".").pop().toLowerCase();
-    this.mimeType = fileExtension === "png" ? "image/png" :
-        (fileExtension === "jpg" || fileExtension === "jpeg") ? "image/jpeg" :
-            fileExtension === "gif" ? "image/gif" : fileExtension === "svg" ? "image/xml+svg" : undefined;
+    switch (fileExtension) {
+        case "jpg":
+        case "jpeg":
+            this.mimeType = "image/jpeg";
+            break;
+        case "gif":
+            this.mimeType = "image/gif";
+            break;
+        case "svg":
+            this.mimeType = "image/svg+xml";
+            break;
+        case "webp":
+            this.mimeType = "image/webp";
+            break;
+        default:
+            this.mimeType = undefined;
+            break;
+    }
    if ( this.mimeType !== undefined) {
        this.dataURI = createURLFromArray(file.fileData, this.mimeType);
        this.data = file;
@@ -331,7 +346,7 @@ function setImage(url) {
                        $("#mainText").innerHTML("<iframe style=\"width:100%;height:700px;border:0\" src=\"data:text/html," + escape(xhr.responseText) + "\"></iframe>");
                    };
                    xhr.send(null);
-                } else if (!/(jpg|jpeg|png|gif)$/.test(imageFiles[currentImage].filename) && imageFiles[currentImage].data.uncompressedSize < 10 * 1024) {
+                } else if (!/(jpg|jpeg|png|gif|webp)$/.test(imageFiles[currentImage].filename) && imageFiles[currentImage].data.uncompressedSize < 10 * 1024) {
                    xhr.open("GET", url, true);
                    xhr.onload = function() {
                        $("#mainText").css("display", "");
@@ -635,6 +650,14 @@ function init(filename) {
    // Focus the scrollable area so that keyboard scrolling work as expected
    $("#mainContent").focus();

+    $("#mainContent").swipe( {
+        swipeRight:function() {
+            showLeftPage();
+        },
+        swipeLeft:function() {
+            showRightPage();
+        },
+    });
    $("#mainImage").click(function(evt) {
        // Firefox does not support offsetX/Y so we have to manually calculate
        // where the user clicked in the image.
@@ -0,0 +1 @@
+!function(a){a.fn.datepicker.dates.el={days:["Κυριακή","Δευτέρα","Τρίτη","Τετάρτη","Πέμπτη","Παρασκευή","Σάββατο"],daysShort:["Κυρ","Δευ","Τρι","Τετ","Πεμ","Παρ","Σαβ"],daysMin:["Κυ","Δε","Τρ","Τε","Πε","Πα","Σα"],months:["Ιανουάριος","Φεβρουάριος","Μάρτιος","Απρίλιος","Μάιος","Ιούνιος","Ιούλιος","Αύγουστος","Σεπτέμβριος","Οκτώβριος","Νοέμβριος","Δεκέμβριος"],monthsShort:["Ιαν","Φεβ","Μαρ","Απρ","Μάι","Ιουν","Ιουλ","Αυγ","Σεπ","Οκτ","Νοε","Δεκ"],today:"Σήμερα",clear:"Καθαρισμός",weekStart:1,format:"d/m/yyyy"}}(jQuery);
@@ -0,0 +1 @@
+!function(a){a.fn.datepicker.dates.tr={days:["Pazar","Pazartesi","Salı","Çarşamba","Perşembe","Cuma","Cumartesi"],daysShort:["Pz","Pzt","Sal","Çrş","Prş","Cu","Cts"],daysMin:["Pz","Pzt","Sa","Çr","Pr","Cu","Ct"],months:["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık"],monthsShort:["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara"],today:"Bugün",clear:"Temizle",weekStart:1,format:"dd.mm.yyyy"}}(jQuery);
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,n){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return n(e)}):"object"==typeof module&&module.exports?module.exports=n(require("jquery")):n(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Vyberte ze seznamu",noneResultsText:"Pro hled\xe1n\xed {0} nebyly nalezeny \u017e\xe1dn\xe9 v\xfdsledky",countSelectedText:"Vybran\xe9 {0} z {1}",maxOptionsText:["Limit p\u0159ekro\u010den ({n} {var} max)","Limit skupiny p\u0159ekro\u010den ({n} {var} max)",["polo\u017eek","polo\u017eka"]],multipleSeparator:", ",selectAllText:"Vybrat v\u0161e",deselectAllText:"Zru\u0161it v\xfdb\u011br"}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Bitte w\xe4hlen...",noneResultsText:"Keine Ergebnisse f\xfcr {0}",countSelectedText:function(e,t){return 1==e?"{0} Element ausgew\xe4hlt":"{0} Elemente ausgew\xe4hlt"},maxOptionsText:function(e,t){return[1==e?"Limit erreicht ({n} Element max.)":"Limit erreicht ({n} Elemente max.)",1==t?"Gruppen-Limit erreicht ({n} Element max.)":"Gruppen-Limit erreicht ({n} Elemente max.)"]},selectAllText:"Alles ausw\xe4hlen",deselectAllText:"Nichts ausw\xe4hlen",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,o){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return o(e)}):"object"==typeof module&&module.exports?module.exports=o(require("jquery")):o(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"No hay selecci\xf3n",noneResultsText:"No hay resultados {0}",countSelectedText:"Seleccionados {0} de {1}",maxOptionsText:["L\xedmite alcanzado ({n} {var} max)","L\xedmite del grupo alcanzado({n} {var} max)",["elementos","element"]],multipleSeparator:", ",selectAllText:"Seleccionar Todos",deselectAllText:"Desmarcar Todos"}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Ei valintoja",noneResultsText:"Ei hakutuloksia {0}",countSelectedText:function(e,t){return 1==e?"{0} valittu":"{0} valitut"},maxOptionsText:function(e,t){return["Valintojen maksimim\xe4\xe4r\xe4 ({n} saavutettu)","Ryhm\xe4n maksimim\xe4\xe4r\xe4 ({n} saavutettu)"]},selectAllText:"Valitse kaikki",deselectAllText:"Poista kaikki",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Aucune s\xe9lection",noneResultsText:"Aucun r\xe9sultat pour {0}",countSelectedText:function(e,t){return 1<e?"{0} \xe9l\xe9ments s\xe9lectionn\xe9s":"{0} \xe9l\xe9ment s\xe9lectionn\xe9"},maxOptionsText:function(e,t){return[1<e?"Limite atteinte ({n} \xe9l\xe9ments max)":"Limite atteinte ({n} \xe9l\xe9ment max)",1<t?"Limite du groupe atteinte ({n} \xe9l\xe9ments max)":"Limite du groupe atteinte ({n} \xe9l\xe9ment max)"]},multipleSeparator:", ",selectAllText:"Tout s\xe9lectionner",deselectAllText:"Tout d\xe9s\xe9lectionner"}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"V\xe1lasszon!",noneResultsText:"Nincs tal\xe1lat {0}",countSelectedText:function(e,t){return"{0} elem kiv\xe1lasztva"},maxOptionsText:function(e,t){return["Legfeljebb {n} elem v\xe1laszthat\xf3","A csoportban legfeljebb {n} elem v\xe1laszthat\xf3"]},selectAllText:"Mind",deselectAllText:"Egyik sem",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Nessuna selezione",noneResultsText:"Nessun risultato per {0}",countSelectedText:function(e,t){return 1==e?"Selezionato {0} di {1}":"Selezionati {0} di {1}"},maxOptionsText:["Limite raggiunto ({n} {var} max)","Limite del gruppo raggiunto ({n} {var} max)",["elementi","elemento"]],multipleSeparator:", ",selectAllText:"Seleziona Tutto",deselectAllText:"Deseleziona Tutto"}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"\u9078\u629e\u3055\u308c\u3066\u3044\u307e\u305b\u3093",noneResultsText:"'{0}'\u306f\u898b\u3064\u304b\u308a\u307e\u305b\u3093",countSelectedText:"{0}/{1} \u9078\u629e\u4e2d",maxOptionsText:["\u9078\u629e\u4e0a\u9650\u6570\u3092\u8d85\u3048\u3066\u3044\u307e\u3059(\u6700\u5927{n}{var})","\u30b0\u30eb\u30fc\u30d7\u306e\u9078\u629e\u4e0a\u9650\u6570\u3092\u8d85\u3048\u3066\u3044\u307e\u3059(\u6700\u5927{n}{var})",["\u30a2\u30a4\u30c6\u30e0","\u30a2\u30a4\u30c6\u30e0"]],selectAllText:"\u5168\u3066\u9078\u629e",deselectAllText:"\u9078\u629e\u3092\u30af\u30ea\u30a2",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"\u1798\u17b7\u1793\u1798\u17b6\u1793\u17a2\u17d2\u179c\u17b8\u1794\u17b6\u1793\u1787\u17d2\u179a\u17be\u179f\u179a\u17be\u179f",noneResultsText:"\u1798\u17b7\u1793\u1798\u17b6\u1793\u179b\u1791\u17d2\u1792\u1795\u179b {0}",countSelectedText:function(e,t){return"{0} \u1792\u17b6\u178f\u17bb\u178a\u17c2\u179b\u1794\u17b6\u1793\u1787\u17d2\u179a\u17be\u179f"},maxOptionsText:function(e,t){return[1==e?"\u1788\u17b6\u1793\u178a\u179b\u17cb\u178a\u17c2\u1793\u1780\u17c6\u178e\u178f\u17cb ( {n} \u1792\u17b6\u178f\u17bb\u17a2\u178f\u17b7\u1794\u179a\u1798\u17b6)":"\u17a2\u178f\u17b7\u1794\u179a\u1798\u17b6\u1788\u17b6\u1793\u178a\u179b\u17cb\u178a\u17c2\u1793\u1780\u17c6\u178e\u178f\u17cb ( {n} \u1792\u17b6\u178f\u17bb)",1==t?"\u178a\u17c2\u1793\u1780\u17c6\u178e\u178f\u17cb\u1780\u17d2\u179a\u17bb\u1798\u1788\u17b6\u1793\u178a\u179b\u17cb ( {n} \u17a2\u178f\u17b7\u1794\u179a\u1798\u17b6\u1792\u17b6\u178f\u17bb)":"\u17a2\u178f\u17b7\u1794\u179a\u1798\u17b6\u1780\u17d2\u179a\u17bb\u1798\u1788\u17b6\u1793\u178a\u179b\u17cb\u178a\u17c2\u1793\u1780\u17c6\u178e\u178f\u17cb ( {n} \u1792\u17b6\u178f\u17bb)"]},selectAllText:"\u1787\u17d2\u179a\u17be\u179f\u200b\u1799\u1780\u200b\u1791\u17b6\u17c6\u1784\u17a2\u179f\u17cb",deselectAllText:"\u1798\u17b7\u1793\u1787\u17d2\u179a\u17be\u179f\u200b\u1799\u1780\u200b\u1791\u17b6\u17c6\u1784\u17a2\u179f",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Niets geselecteerd",noneResultsText:"Geen resultaten gevonden voor {0}",countSelectedText:"{0} van {1} geselecteerd",maxOptionsText:["Limiet bereikt ({n} {var} max)","Groep limiet bereikt ({n} {var} max)",["items","item"]],selectAllText:"Alles selecteren",deselectAllText:"Alles deselecteren",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,n){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return n(e)}):"object"==typeof module&&module.exports?module.exports=n(require("jquery")):n(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Nic nie zaznaczono",noneResultsText:"Brak wynik\xf3w wyszukiwania {0}",countSelectedText:"Zaznaczono {0} z {1}",maxOptionsText:["Osi\u0105gni\u0119to limit ({n} {var} max)","Limit grupy osi\u0105gni\u0119ty ({n} {var} max)",["elementy","element"]],selectAllText:"Zaznacz wszystkie",deselectAllText:"Odznacz wszystkie",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"\u041d\u0438\u0447\u0435\u0433\u043e \u043d\u0435 \u0432\u044b\u0431\u0440\u0430\u043d\u043e",noneResultsText:"\u0421\u043e\u0432\u043f\u0430\u0434\u0435\u043d\u0438\u0439 \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d\u043e {0}",countSelectedText:"\u0412\u044b\u0431\u0440\u0430\u043d\u043e {0} \u0438\u0437 {1}",maxOptionsText:["\u0414\u043e\u0441\u0442\u0438\u0433\u043d\u0443\u0442 \u043f\u0440\u0435\u0434\u0435\u043b ({n} {var} \u043c\u0430\u043a\u0441\u0438\u043c\u0443\u043c)","\u0414\u043e\u0441\u0442\u0438\u0433\u043d\u0443\u0442 \u043f\u0440\u0435\u0434\u0435\u043b \u0432 \u0433\u0440\u0443\u043f\u043f\u0435 ({n} {var} \u043c\u0430\u043a\u0441\u0438\u043c\u0443\u043c)",["\u0448\u0442.","\u0448\u0442."]],doneButtonText:"\u0417\u0430\u043a\u0440\u044b\u0442\u044c",selectAllText:"\u0412\u044b\u0431\u0440\u0430\u0442\u044c \u0432\u0441\u0435",deselectAllText:"\u041e\u0442\u043c\u0435\u043d\u0438\u0442\u044c \u0432\u0441\u0435",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Inget valt",noneResultsText:"Inget s\xf6kresultat matchar {0}",countSelectedText:function(e,t){return 1===e?"{0} alternativ valt":"{0} alternativ valda"},maxOptionsText:function(e,t){return["Gr\xe4ns uppn\xe5d (max {n} alternativ)","Gr\xe4ns uppn\xe5d (max {n} gruppalternativ)"]},selectAllText:"Markera alla",deselectAllText:"Avmarkera alla",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,i){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return i(e)}):"object"==typeof module&&module.exports?module.exports=i(require("jquery")):i(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Hi\xe7biri se\xe7ilmedi",noneResultsText:"Hi\xe7bir sonu\xe7 bulunamad\u0131 {0}",countSelectedText:function(e,i){return"{0} \xf6\u011fe se\xe7ildi"},maxOptionsText:function(e,i){return[1==e?"Limit a\u015f\u0131ld\u0131 (maksimum {n} say\u0131da \xf6\u011fe )":"Limit a\u015f\u0131ld\u0131 (maksimum {n} say\u0131da \xf6\u011fe)","Grup limiti a\u015f\u0131ld\u0131 (maksimum {n} say\u0131da \xf6\u011fe)"]},selectAllText:"T\xfcm\xfcn\xfc Se\xe7",deselectAllText:"Se\xe7iniz",multipleSeparator:", "}});
@@ -0,0 +1,8 @@
+/*!
+ * Bootstrap-select v1.13.14 (https://developer.snapappointments.com/bootstrap-select)
+ *
+ * Copyright 2012-2020 SnapAppointments, LLC
+ * Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
+ */
+
+!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"\u6ca1\u6709\u9009\u4e2d\u4efb\u4f55\u9879",noneResultsText:"\u6ca1\u6709\u627e\u5230\u5339\u914d\u9879",countSelectedText:"\u9009\u4e2d{1}\u4e2d\u7684{0}\u9879",maxOptionsText:["\u8d85\u51fa\u9650\u5236 (\u6700\u591a\u9009\u62e9{n}\u9879)","\u7ec4\u9009\u62e9\u8d85\u51fa\u9650\u5236(\u6700\u591a\u9009\u62e9{n}\u7ec4)"],multipleSeparator:", ",selectAllText:"\u5168\u9009",deselectAllText:"\u53d6\u6d88\u5168\u9009"}});
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				!function(a){a.fn.datepicker.dates.el={days:["Κυριακή","Δευτέρα","Τρίτη","Τετάρτη","Πέμπτη","Παρασκευή","Σάββατο"],daysShort:["Κυρ","Δευ","Τρι","Τετ","Πεμ","Παρ","Σαβ"],daysMin:["Κυ","Δε","Τρ","Τε","Πε","Πα","Σα"],months:["Ιανουάριος","Φεβρουάριος","Μάρτιος","Απρίλιος","Μάιος","Ιούνιος","Ιούλιος","Αύγουστος","Σεπτέμβριος","Οκτώβριος","Νοέμβριος","Δεκέμβριος"],monthsShort:["Ιαν","Φεβ","Μαρ","Απρ","Μάι","Ιουν","Ιουλ","Αυγ","Σεπ","Οκτ","Νοε","Δεκ"],today:"Σήμερα",clear:"Καθαρισμός",weekStart:1,format:"d/m/yyyy"}}(jQuery);
				`@@ -0,0 +1 @@`
				`!function(a){a.fn.datepicker.dates.tr={days:["Pazar","Pazartesi","Salı","Çarşamba","Perşembe","Cuma","Cumartesi"],daysShort:["Pz","Pzt","Sal","Çrş","Prş","Cu","Cts"],daysMin:["Pz","Pzt","Sa","Çr","Pr","Cu","Ct"],months:["Ocak","Şubat","Mart","Nisan","Mayıs","Haziran","Temmuz","Ağustos","Eylül","Ekim","Kasım","Aralık"],monthsShort:["Oca","Şub","Mar","Nis","May","Haz","Tem","Ağu","Eyl","Eki","Kas","Ara"],today:"Bugün",clear:"Temizle",weekStart:1,format:"dd.mm.yyyy"}}(jQuery);`