Update version to 0.6.13 for release

Merge remote-tracking branch 'pt_br/patch-1'
Update test results
2021-09-25 08:34:20 +02:00 · 2021-09-25 08:25:06 +02:00 · 2021-09-25 08:23:14 +02:00 · 2021-09-25 01:07:31 -03:00 · 2021-09-22 20:43:29 +02:00 · 2021-09-22 20:34:18 +02:00
300 changed files with 25146 additions and 18048 deletions
@@ -6,6 +6,7 @@ __pycache__/

 # Distribution / packaging
 .Python
+.python-version
 env/
 venv/
 eggs/
@@ -41,6 +41,6 @@ Open a new GitHub pull request with the patch. Ensure the PR description clearly

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

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

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

-![GitHub License](https://img.shields.io/github/license/janeczku/calibre-web) ![GitHub Downloads](https://img.shields.io/github/downloads/janeczku/calibre-web/total) ![GitHub commit activity](https://img.shields.io/github/commit-activity/w/janeczku/calibre-web?logo=github) [![Discord](https://img.shields.io/discord/838810113564344381?label=Discord&logo=discord)](https://discord.gg/h2VsJ2NEfB) 
+[![GitHub License](https://img.shields.io/github/license/janeczku/calibre-web?style=flat-square)](https://github.com/janeczku/calibre-web/blob/master/LICENSE)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/w/janeczku/calibre-web?logo=github&style=flat-square&label=commits)]()
+[![GitHub all releases](https://img.shields.io/github/downloads/janeczku/calibre-web/total?logo=github&style=flat-square)](https://github.com/janeczku/calibre-web/releases)
+[![PyPI](https://img.shields.io/pypi/v/calibreweb?logo=pypi&logoColor=fff&style=flat-square)](https://pypi.org/project/calibreweb/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/calibreweb?logo=pypi&logoColor=fff&style=flat-square)](https://pypi.org/project/calibreweb/)
+[![Discord](https://img.shields.io/discord/838810113564344381?label=Discord&logo=discord&style=flat-square)](https://discord.gg/h2VsJ2NEfB)

 *This software is a fork of [library](https://github.com/mutschler/calibreserver) and licensed under the GPL v3 License.*

@@ -34,12 +39,19 @@ Calibre-Web is a web app providing a clean interface for browsing, reading and d

 ## Quick start

+#### Install via pip
+1. Install calibre web via pip with the command `pip install calibreweb` (Depending on your OS and or distro the command could also be `pip3`). 
+2. Optional features can also be installed via pip, please refer to [this page](https://github.com/janeczku/calibre-web/wiki/Dependencies-in-Calibre-Web-Linux-Windows) for details 
+3. Calibre-Web can be started afterwards by typing `cps` or `python3 -m cps` 
+
+#### Manual installation
 1. Install dependencies by running `pip3 install --target vendor -r requirements.txt` (python3.x). Alternativly set up a python virtual environment.
 2. Execute the command: `python3 cps.py` (or `nohup python3 cps.py` - recommended if you want to exit the terminal window)
-3. Point your browser to `http://localhost:8083` or `http://localhost:8083/opds` for the OPDS catalog
-4. Set `Location of Calibre database` to the path of the folder where your Calibre library (metadata.db) lives, push "submit" button\
-   Optionally a Google Drive can be used to host the calibre library [-> Using Google Drive integration](https://github.com/janeczku/calibre-web/wiki/Configuration#using-google-drive-integration)
-5. Go to Login page
+   
+Point your browser to `http://localhost:8083` or `http://localhost:8083/opds` for the OPDS catalog
+Set `Location of Calibre database` to the path of the folder where your Calibre library (metadata.db) lives, push "submit" button\
+Optionally a Google Drive can be used to host the calibre library [-> Using Google Drive integration](https://github.com/janeczku/calibre-web/wiki/Configuration#using-google-drive-integration)
+Go to Login page

 **Default admin login:**\
 *Username:* admin\
@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to ozzie.fernandez.isaacs@googlemail.com
@@ -70,7 +70,6 @@ def main():
    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,11 @@ from . import config_sql, logger, cache_buster, cli, ub, db
 from .reverseproxy import ReverseProxied
 from .server import WebServer

+try:
+    import lxml
+    lxml_present = True
+except ImportError:
+    lxml_present = False

 mimetypes.init()
 mimetypes.add_type('application/xhtml+xml', '.xhtml')
@@ -83,11 +88,23 @@ log = logger.create()

 from . import services

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

 calibre_db = db.CalibreDB()

 def create_app():
+    if sys.version_info < (3, 0):
+        log.info(
+            '*** Python2 is EOL since end of 2019, this version of Calibre-Web is no longer supporting Python2, please update your installation to Python3 ***')
+        print(
+            '*** Python2 is EOL since end of 2019, this version of Calibre-Web is no longer supporting Python2, please update your installation to Python3 ***')
+        sys.exit(5)
+    if not lxml_present:
+        log.info('*** "lxml" is needed for calibre-web to run. Please install it using pip: "pip install lxml" ***')
+        print('*** "lxml" is needed for calibre-web to run. Please install it using pip: "pip install lxml" ***')
+        sys.exit(6)
    app.wsgi_app = ReverseProxied(app.wsgi_app)
    # For python2 convert path to unicode
    if sys.version_info < (3, 0):
@@ -97,11 +114,8 @@ def create_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 is no longer supporting Python2 please consider upgrading to Python3')
-        print('Python2 is EOL since end of 2019, this version of Calibre-Web is no longer 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))
@@ -54,6 +54,12 @@ try:
 except ImportError:
    greenlet_Version = None

+try:
+    from scholarly import scholarly
+    scholarly_version = _(u'installed')
+except ImportError:
+    scholarly_version = _(u'not installed')
+
 from . import services

 about = flask.Blueprint('about', __name__)
@@ -79,6 +85,7 @@ _VERSIONS = OrderedDict(
    iso639=isoLanguages.__version__,
    pytz=pytz.__version__,
    Unidecode = unidecode_version,
+    Scholarly = scholarly_version,
    Flask_SimpleLDAP =  u'installed' if bool(services.ldap) else None,
    python_LDAP = services.ldapVersion if bool(services.ldapVersion) else None,
    Goodreads = u'installed' if bool(services.goodreads_support) else None,
@@ -34,13 +34,13 @@ from babel.dates import format_datetime
 from flask import Blueprint, flash, redirect, url_for, abort, request, make_response, send_from_directory, g, Response
 from flask_login import login_required, current_user, logout_user, confirm_login
 from flask_babel import gettext as _
+from flask import session as flask_session
 from sqlalchemy import and_
 from sqlalchemy.orm.attributes import flag_modified
 from sqlalchemy.exc import IntegrityError, OperationalError, InvalidRequestError
 from sqlalchemy.sql.expression import func, or_, text

 from . import constants, logger, helper, services
-from .cli import filepicker
 from . import db, calibre_db, ub, web_server, get_locale, config, updater_thread, babel, gdriveutils
 from .helper import check_valid_domain, send_test_mail, reset_password, generate_password_hash, check_email, \
    valid_email, check_username
@@ -97,23 +97,13 @@ def admin_required(f):
    return inner


-def unconfigured(f):
-    """
-    Checks if calibre-web instance is not configured
-    """
-    @wraps(f)
-    def inner(*args, **kwargs):
-        if not config.db_configured:
-            return f(*args, **kwargs)
-        abort(403)
-
-    return inner
-
-
@admi.before_app_request
 def before_request():
+    # make remember me function work
    if current_user.is_authenticated:
        confirm_login()
+    if not ub.check_user_session(current_user.id, flask_session.get('_id')) and 'opds' not in request.path:
+        logout_user()
    g.constants = constants
    g.user = current_user
    g.allow_registration = config.config_public_reg
@@ -124,10 +114,14 @@ def before_request():
    g.shelves_access = ub.session.query(ub.Shelf).filter(
        or_(ub.Shelf.is_public == 1, ub.Shelf.user_id == current_user.id)).order_by(ub.Shelf.name).all()
    if '/static/' not in request.path and not config.db_configured and \
-        request.endpoint not in ('admin.basic_configuration',
-                                 'login',
-                                 'admin.config_pathchooser'):
-        return redirect(url_for('admin.basic_configuration'))
+        request.endpoint not in ('admin.ajax_db_config',
+                                 'admin.simulatedbchange',
+                                 'admin.db_configuration',
+                                 'web.login',
+                                 'web.logout',
+                                 'admin.load_dialogtexts',
+                                 'admin.ajax_pathchooser'):
+        return redirect(url_for('admin.db_configuration'))


@admi.route("/admin")
@@ -194,16 +188,46 @@ def admin():
                                 feature_support=feature_support, kobo_support=kobo_support,
                                 title=_(u"Admin page"), page="admin")

+@admi.route("/admin/dbconfig", methods=["GET", "POST"])
+@login_required
+@admin_required
+def db_configuration():
+    if request.method == "POST":
+        return _db_configuration_update_helper()
+    return _db_configuration_result()

-@admi.route("/admin/config", methods=["GET", "POST"])
+
+@admi.route("/admin/config", methods=["GET"])
@login_required
@admin_required
 def configuration():
-    if request.method == "POST":
-        return _configuration_update_helper(True)
-    return _configuration_result()
+    return render_title_template("config_edit.html",
+                                 config=config,
+                                 provider=oauthblueprints,
+                                 feature_support=feature_support,
+                                 title=_(u"Basic Configuration"), page="config")


+@admi.route("/admin/ajaxconfig", methods=["POST"])
+@login_required
+@admin_required
+def ajax_config():
+    return _configuration_update_helper()
+
+
+@admi.route("/admin/ajaxdbconfig", methods=["POST"])
+@login_required
+@admin_required
+def ajax_db_config():
+    return _db_configuration_update_helper()
+
+
+@admi.route("/admin/alive", methods=["GET"])
+@login_required
+@admin_required
+def calibreweb_alive():
+    return "", 200
+
@admi.route("/admin/viewconfig")
@login_required
@admin_required
@@ -236,7 +260,7 @@ def edit_user_table():
        custom_values = []
    if not config.config_anonbrowse:
        allUser = allUser.filter(ub.User.role.op('&')(constants.ROLE_ANONYMOUS) != constants.ROLE_ANONYMOUS)
-
+    kobo_support = feature_support['kobo'] and config.config_kobo_sync
    return render_title_template("user_table.html",
                                 users=allUser.all(),
                                 tags=tags,
@@ -245,6 +269,7 @@ def edit_user_table():
                                 languages=languages,
                                 visiblility=visibility,
                                 all_roles=constants.ALL_ROLES,
+                                 kobo_support=kobo_support,
                                 sidebar_settings=constants.sidebar_settings,
                                 title=_(u"Edit Users"),
                                 page="usertable")
@@ -391,6 +416,8 @@ def edit_list_user(param):
                    user.name = check_username(vals['value'])
                elif param =='email':
                    user.email = check_email(vals['value'])
+                elif param =='kobo_only_shelves_sync':
+                    user.kobo_only_shelves_sync = int(vals['value'] == 'true')
                elif param == 'kindle_mail':
                    user.kindle_mail = valid_email(vals['value']) if vals['value'] else ""
                elif param.endswith('role'):
@@ -495,30 +522,30 @@ def check_valid_restricted_column(column):
 def update_view_configuration():
    to_save = request.form.to_dict()

-    _config_string = lambda x: config.set_from_dictionary(to_save, x, lambda y: y.strip() if y else y)
-    _config_int = lambda x: config.set_from_dictionary(to_save, x, int)
+    # _config_string = lambda x: config.set_from_dictionary(to_save, x, lambda y: y.strip() if y else y)
+    # _config_int = lambda x: config.set_from_dictionary(to_save, x, int)

-    _config_string("config_calibre_web_title")
-    _config_string("config_columns_to_ignore")
-    if _config_string("config_title_regex"):
+    _config_string(to_save, "config_calibre_web_title")
+    _config_string(to_save, "config_columns_to_ignore")
+    if _config_string(to_save, "config_title_regex"):
        calibre_db.update_title_sort(config)

    if not check_valid_read_column(to_save.get("config_read_column", "0")):
        flash(_(u"Invalid Read Column"), category="error")
        log.debug("Invalid Read column")
        return view_configuration()
-    _config_int("config_read_column")
+    _config_int(to_save, "config_read_column")

    if not check_valid_restricted_column(to_save.get("config_restricted_column", "0")):
        flash(_(u"Invalid Restricted Column"), category="error")
        log.debug("Invalid Restricted Column")
        return view_configuration()
-    _config_int("config_restricted_column")
+    _config_int(to_save, "config_restricted_column")

-    _config_int("config_theme")
-    _config_int("config_random_books")
-    _config_int("config_books_per_page")
-    _config_int("config_authors_max")
+    _config_int(to_save, "config_theme")
+    _config_int(to_save, "config_random_books")
+    _config_int(to_save, "config_books_per_page")
+    _config_int(to_save, "config_authors_max")


    config.config_default_role = constants.selected_roles(to_save)
@@ -536,10 +563,10 @@ def update_view_configuration():
    return view_configuration()


-@admi.route("/ajax/loaddialogtexts/<element_id>")
+@admi.route("/ajax/loaddialogtexts/<element_id>", methods=['POST'])
@login_required
 def load_dialogtexts(element_id):
-    texts = {"header": "", "main": ""}
+    texts = {"header": "", "main": "", "valid": 1}
    if element_id == "config_delete_kobo_token":
        texts["main"] = _('Do you really want to delete the Kobo Token?')
    elif element_id == "btndeletedomain":
@@ -558,6 +585,10 @@ def load_dialogtexts(element_id):
        texts["main"] = _('Are you sure you want to change the selected restrictions for the selected user(s)?')
    elif element_id == "sidebar_view":
        texts["main"] = _('Are you sure you want to change the selected visibility restrictions for the selected user(s)?')
+    elif element_id == "kobo_only_shelves_sync":
+        texts["main"] = _('Are you sure you want to change shelf sync behavior for the selected user(s)?')
+    elif element_id == "db_submit":
+        texts["main"] = _('Are you sure you want to change Calibre library location?')
    return json.dumps(texts)


@@ -857,19 +888,11 @@ def list_restriction(res_type, user_id):
    else:
        json_dumps = ""
    js = json.dumps(json_dumps)
-    response = make_response(js.replace("'", '"'))
+    response = make_response(js) #.replace("'", '"')
    response.headers["Content-Type"] = "application/json; charset=utf-8"
    return response


-@admi.route("/basicconfig/pathchooser/")
-@unconfigured
-def config_pathchooser():
-    if filepicker:
-        return pathchooser()
-    abort(403)
-
-
@admi.route("/ajax/pathchooser/")
@login_required
@admin_required
@@ -958,16 +981,6 @@ def pathchooser():
    return json.dumps(context)


-@admi.route("/basicconfig", methods=["GET", "POST"])
-@unconfigured
-def basic_configuration():
-    logout_user()
-    if request.method == "POST":
-        log.debug("Basic Configuration send")
-        return _configuration_update_helper(configured=filepicker)
-    return _configuration_result(configured=filepicker)
-
-
 def _config_int(to_save, x, func=int):
    return config.set_from_dictionary(to_save, x, func)

@@ -986,23 +999,24 @@ def _config_string(to_save, x):

 def _configuration_gdrive_helper(to_save):
    gdrive_error = None
-    gdrive_secrets = {}
+    if to_save.get("config_use_google_drive"):
+        gdrive_secrets = {}

-    if not os.path.isfile(gdriveutils.SETTINGS_YAML):
-        config.config_use_google_drive = False
+        if not os.path.isfile(gdriveutils.SETTINGS_YAML):
+            config.config_use_google_drive = False

-    if gdrive_support:
-        gdrive_error = gdriveutils.get_error_text(gdrive_secrets)
-    if "config_use_google_drive" in to_save and not config.config_use_google_drive and not gdrive_error:
-        with open(gdriveutils.CLIENT_SECRETS, 'r') as settings:
-            gdrive_secrets = json.load(settings)['web']
-        if not gdrive_secrets:
-            return _configuration_result(_('client_secrets.json Is Not Configured For Web Application'))
-        gdriveutils.update_settings(
-                            gdrive_secrets['client_id'],
-                            gdrive_secrets['client_secret'],
-                            gdrive_secrets['redirect_uris'][0]
-                        )
+        if gdrive_support:
+            gdrive_error = gdriveutils.get_error_text(gdrive_secrets)
+        if "config_use_google_drive" in to_save and not config.config_use_google_drive and not gdrive_error:
+            with open(gdriveutils.CLIENT_SECRETS, 'r') as settings:
+                gdrive_secrets = json.load(settings)['web']
+            if not gdrive_secrets:
+                return _configuration_result(_('client_secrets.json Is Not Configured For Web Application'))
+            gdriveutils.update_settings(
+                                gdrive_secrets['client_id'],
+                                gdrive_secrets['client_secret'],
+                                gdrive_secrets['redirect_uris'][0]
+                            )

    # always show google drive settings, but in case of error deny support
    new_gdrive_value = (not gdrive_error) and ("config_use_google_drive" in to_save)
@@ -1036,23 +1050,23 @@ def _configuration_oauth_helper(to_save):
    return reboot_required


-def _configuration_logfile_helper(to_save, gdrive_error):
+def _configuration_logfile_helper(to_save):
    reboot_required = False
    reboot_required |= _config_int(to_save, "config_log_level")
    reboot_required |= _config_string(to_save, "config_logfile")
    if not logger.is_valid_logfile(config.config_logfile):
        return reboot_required, \
-               _configuration_result(_('Logfile Location is not Valid, Please Enter Correct Path'), gdrive_error)
+               _configuration_result(_('Logfile Location is not Valid, Please Enter Correct Path'))

    reboot_required |= _config_checkbox_int(to_save, "config_access_log")
    reboot_required |= _config_string(to_save, "config_access_logfile")
    if not logger.is_valid_logfile(config.config_access_logfile):
        return reboot_required, \
-               _configuration_result(_('Access Logfile Location is not Valid, Please Enter Correct Path'), gdrive_error)
+               _configuration_result(_('Access Logfile Location is not Valid, Please Enter Correct Path'))
    return reboot_required, None


-def _configuration_ldap_helper(to_save, gdrive_error):
+def _configuration_ldap_helper(to_save):
    reboot_required = False
    reboot_required |= _config_string(to_save, "config_ldap_provider_url")
    reboot_required |= _config_int(to_save, "config_ldap_port")
@@ -1079,44 +1093,37 @@ def _configuration_ldap_helper(to_save, gdrive_error):
        or not config.config_ldap_dn \
        or not config.config_ldap_user_object:
        return reboot_required, _configuration_result(_('Please Enter a LDAP Provider, '
-                                                        'Port, DN and User Object Identifier'), gdrive_error)
+                                                        'Port, DN and User Object Identifier'))

    if config.config_ldap_authentication > constants.LDAP_AUTH_ANONYMOUS:
        if config.config_ldap_authentication > constants.LDAP_AUTH_UNAUTHENTICATE:
            if not config.config_ldap_serv_username or not bool(config.config_ldap_serv_password):
-                return reboot_required, _configuration_result('Please Enter a LDAP Service Account and Password',
-                                                              gdrive_error)
+                return reboot_required, _configuration_result(_('Please Enter a LDAP Service Account and Password'))
        else:
            if not config.config_ldap_serv_username:
-                return reboot_required, _configuration_result('Please Enter a LDAP Service Account', gdrive_error)
+                return reboot_required, _configuration_result(_('Please Enter a LDAP Service Account'))

    if config.config_ldap_group_object_filter:
        if config.config_ldap_group_object_filter.count("%s") != 1:
            return reboot_required, \
-                   _configuration_result(_('LDAP Group Object Filter Needs to Have One "%s" Format Identifier'),
-                                         gdrive_error)
+                   _configuration_result(_('LDAP Group Object Filter Needs to Have One "%s" Format Identifier'))
        if config.config_ldap_group_object_filter.count("(") != config.config_ldap_group_object_filter.count(")"):
-            return reboot_required, _configuration_result(_('LDAP Group Object Filter Has Unmatched Parenthesis'),
-                                                          gdrive_error)
+            return reboot_required, _configuration_result(_('LDAP Group Object Filter Has Unmatched Parenthesis'))

    if config.config_ldap_user_object.count("%s") != 1:
        return reboot_required, \
-               _configuration_result(_('LDAP User Object Filter needs to Have One "%s" Format Identifier'),
-                                     gdrive_error)
+               _configuration_result(_('LDAP User Object Filter needs to Have One "%s" Format Identifier'))
    if config.config_ldap_user_object.count("(") != config.config_ldap_user_object.count(")"):
-        return reboot_required, _configuration_result(_('LDAP User Object Filter Has Unmatched Parenthesis'),
-                                                      gdrive_error)
+        return reboot_required, _configuration_result(_('LDAP User Object Filter Has Unmatched Parenthesis'))

    if to_save.get("ldap_import_user_filter") == '0':
        config.config_ldap_member_user_object = ""
    else:
        if config.config_ldap_member_user_object.count("%s") != 1:
            return reboot_required, \
-                   _configuration_result(_('LDAP Member User Filter needs to Have One "%s" Format Identifier'),
-                                         gdrive_error)
+                   _configuration_result(_('LDAP Member User Filter needs to Have One "%s" Format Identifier'))
        if config.config_ldap_member_user_object.count("(") != config.config_ldap_member_user_object.count(")"):
-            return reboot_required, _configuration_result(_('LDAP Member User Filter Has Unmatched Parenthesis'),
-                                                          gdrive_error)
+            return reboot_required, _configuration_result(_('LDAP Member User Filter Has Unmatched Parenthesis'))

    if config.config_ldap_cacert_path or config.config_ldap_cert_path or config.config_ldap_key_path:
        if not (os.path.isfile(config.config_ldap_cacert_path) and
@@ -1124,13 +1131,31 @@ def _configuration_ldap_helper(to_save, gdrive_error):
                os.path.isfile(config.config_ldap_key_path)):
            return reboot_required, \
                   _configuration_result(_('LDAP CACertificate, Certificate or Key Location is not Valid, '
-                                           'Please Enter Correct Path'),
-                                         gdrive_error)
+                                           'Please Enter Correct Path'))
    return reboot_required, None


-def _configuration_update_helper(configured):
-    reboot_required = False
+@admi.route("/ajax/simulatedbchange", methods=['POST'])
+@login_required
+@admin_required
+def simulatedbchange():
+    db_change, db_valid = _db_simulate_change()
+    return Response(json.dumps({"change": db_change, "valid": db_valid}), mimetype='application/json')
+
+
+def _db_simulate_change():
+    param = request.form.to_dict()
+    to_save = {}
+    to_save['config_calibre_dir'] = re.sub(r'[\\/]metadata\.db$',
+                                           '',
+                                           param['config_calibre_dir'],
+                                           flags=re.IGNORECASE).strip()
+    db_change = config.config_calibre_dir != to_save["config_calibre_dir"] and config.config_calibre_dir
+    db_valid = calibre_db.check_valid_db(to_save["config_calibre_dir"], ub.app_DB_path)
+    return db_change, db_valid
+
+
+def _db_configuration_update_helper():
    db_change = False
    to_save = request.form.to_dict()
    gdrive_error = None
@@ -1140,24 +1165,47 @@ def _configuration_update_helper(configured):
                                           to_save['config_calibre_dir'],
                                           flags=re.IGNORECASE)
    try:
-        db_change |= _config_string(to_save, "config_calibre_dir")
+        db_change, db_valid = _db_simulate_change()

        # gdrive_error drive setup
        gdrive_error = _configuration_gdrive_helper(to_save)
+    except (OperationalError, InvalidRequestError):
+        ub.session.rollback()
+        log.error("Settings DB is not Writeable")
+        _db_configuration_result(_("Settings DB is not Writeable"), gdrive_error)
+    try:
+        metadata_db = os.path.join(to_save['config_calibre_dir'], "metadata.db")
+        if config.config_use_google_drive and is_gdrive_ready() and not os.path.exists(metadata_db):
+            gdriveutils.downloadFile(None, "metadata.db", metadata_db)
+            db_change = True
+    except Exception as ex:
+        return _db_configuration_result('{}'.format(ex), gdrive_error)

+    if db_change or not db_valid or not config.db_configured:
+        if not calibre_db.setup_db(to_save['config_calibre_dir'], ub.app_DB_path):
+            return _db_configuration_result(_('DB Location is not Valid, Please Enter Correct Path'),
+                                            gdrive_error)
+        _config_string(to_save, "config_calibre_dir")
+        calibre_db.update_config(config)
+        if not os.access(os.path.join(config.config_calibre_dir, "metadata.db"), os.W_OK):
+            flash(_(u"DB is not Writeable"), category="warning")
+            # warning = {'type': "warning", 'message': _(u"DB is not Writeable")}
+    config.save()
+    return _db_configuration_result(None, gdrive_error)
+
+def _configuration_update_helper():
+    reboot_required = False
+    to_save = request.form.to_dict()
+    try:
        reboot_required |= _config_int(to_save, "config_port")

        reboot_required |= _config_string(to_save, "config_keyfile")
        if config.config_keyfile and not os.path.isfile(config.config_keyfile):
-            return _configuration_result(_('Keyfile Location is not Valid, Please Enter Correct Path'),
-                                         gdrive_error,
-                                         configured)
+            return _configuration_result(_('Keyfile Location is not Valid, Please Enter Correct Path'))

        reboot_required |= _config_string(to_save, "config_certfile")
        if config.config_certfile and not os.path.isfile(config.config_certfile):
-            return _configuration_result(_('Certfile Location is not Valid, Please Enter Correct Path'),
-                                         gdrive_error,
-                                         configured)
+            return _configuration_result(_('Certfile Location is not Valid, Please Enter Correct Path'))

        _config_checkbox_int(to_save, "config_uploading")
        # Reboot on config_anonbrowse with enabled ldap, as decoraters are changed in this case
@@ -1181,15 +1229,14 @@ def _configuration_update_helper(configured):

        reboot_required |= _config_int(to_save, "config_login_type")

-        # LDAP configurator,
+        # LDAP configurator
        if config.config_login_type == constants.LOGIN_LDAP:
-            reboot, message = _configuration_ldap_helper(to_save, gdrive_error)
+            reboot, message = _configuration_ldap_helper(to_save)
            if message:
                return message
            reboot_required |= reboot

        # Remote login configuration
-
        _config_checkbox(to_save, "config_remote_login")
        if not config.config_remote_login:
            ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.token_type == 0).delete()
@@ -1213,7 +1260,7 @@ def _configuration_update_helper(configured):
        if config.config_login_type == constants.LOGIN_OAUTH:
            reboot_required |= _configuration_oauth_helper(to_save)

-        reboot, message = _configuration_logfile_helper(to_save, gdrive_error)
+        reboot, message = _configuration_logfile_helper(to_save)
        if message:
            return message
        reboot_required |= reboot
@@ -1222,67 +1269,55 @@ def _configuration_update_helper(configured):
        if "config_rarfile_location" in to_save:
            unrar_status = helper.check_unrar(config.config_rarfile_location)
            if unrar_status:
-                return _configuration_result(unrar_status, gdrive_error, configured)
+                return _configuration_result(unrar_status)
    except (OperationalError, InvalidRequestError):
        ub.session.rollback()
        log.error("Settings DB is not Writeable")
-        _configuration_result(_("Settings DB is not Writeable"), gdrive_error, configured)
-
-    try:
-        metadata_db = os.path.join(config.config_calibre_dir, "metadata.db")
-        if config.config_use_google_drive and is_gdrive_ready() and not os.path.exists(metadata_db):
-            gdriveutils.downloadFile(None, "metadata.db", metadata_db)
-            db_change = True
-    except Exception as ex:
-        return _configuration_result('%s' % ex, gdrive_error, configured)
-
-    if db_change:
-        if not calibre_db.setup_db(config, ub.app_DB_path):
-            return _configuration_result(_('DB Location is not Valid, Please Enter Correct Path'),
-                                         gdrive_error,
-                                         configured)
-        if not os.access(os.path.join(config.config_calibre_dir, "metadata.db"), os.W_OK):
-            flash(_(u"DB is not Writeable"), category="warning")
+        _configuration_result(_("Settings DB is not Writeable"))

    config.save()
-    flash(_(u"Calibre-Web configuration updated"), category="success")
    if reboot_required:
        web_server.stop(True)

-    return _configuration_result(None, gdrive_error, configured)
+    return _configuration_result(None, reboot_required)
+
+def _configuration_result(error_flash=None, reboot=False):
+    resp = {}
+    if error_flash:
+        log.error(error_flash)
+        config.load()
+        resp['result'] = [{'type': "danger", 'message': error_flash}]
+    else:
+        resp['result'] = [{'type': "success", 'message':_(u"Calibre-Web configuration updated")}]
+    resp['reboot'] = reboot
+    resp['config_upload']= config.config_upload_formats
+    return Response(json.dumps(resp), mimetype='application/json')


-def _configuration_result(error_flash=None, gdrive_error=None, configured=True):
+def _db_configuration_result(error_flash=None, gdrive_error=None):
    gdrive_authenticate = not is_gdrive_ready()
    gdrivefolders = []
-    if gdrive_error is None:
+    if not gdrive_error and config.config_use_google_drive:
        gdrive_error = gdriveutils.get_error_text()
    if gdrive_error and gdrive_support:
        log.error(gdrive_error)
        gdrive_error = _(gdrive_error)
+        flash(gdrive_error, category="error")
    else:
        if not gdrive_authenticate and gdrive_support:
            gdrivefolders = gdriveutils.listRootFolders()
-
-    show_back_button = current_user.is_authenticated
-    show_login_button = config.db_configured and not current_user.is_authenticated
    if error_flash:
        log.error(error_flash)
        config.load()
        flash(error_flash, category="error")
-        show_login_button = False

-    return render_title_template("config_edit.html",
+    return render_title_template("config_db.html",
                                 config=config,
-                                 provider=oauthblueprints,
-                                 show_back_button=show_back_button,
-                                 show_login_button=show_login_button,
                                 show_authenticate_google_drive=gdrive_authenticate,
-                                 filepicker=configured,
                                 gdriveError=gdrive_error,
                                 gdrivefolders=gdrivefolders,
                                 feature_support=feature_support,
-                                 title=_(u"Basic Configuration"), page="config")
+                                 title=_(u"Database Configuration"), page="dbconfig")


 def _handle_new_user(to_save, content, languages, translations, kobo_support):
@@ -1317,6 +1352,8 @@ def _handle_new_user(to_save, content, languages, translations, kobo_support):
        content.denied_tags = config.config_denied_tags
        content.allowed_column_value = config.config_allowed_column_value
        content.denied_column_value = config.config_denied_column_value
+        # No default value for kobo sync shelf setting
+        content.kobo_only_shelves_sync = to_save.get("kobo_only_shelves_sync", 0) == "on"
        ub.session.add(content)
        ub.session.commit()
        flash(_(u"User '%(user)s' created", user=content.name), category="success")
@@ -1335,6 +1372,13 @@ def _delete_user(content):
    if ub.session.query(ub.User).filter(ub.User.role.op('&')(constants.ROLE_ADMIN) == constants.ROLE_ADMIN,
                                        ub.User.id != content.id).count():
        if content.name != "Guest":
+            # Delete all books in shelfs belonging to user, all shelfs of user, downloadstat of user, read status
+            # and user itself
+            ub.session.query(ub.ReadBook).filter(content.id == ub.ReadBook.user_id).delete()
+            ub.session.query(ub.Downloads).filter(content.id == ub.Downloads.user_id).delete()
+            for us in ub.session.query(ub.Shelf).filter(content.id == ub.Shelf.user_id):
+                ub.session.query(ub.BookShelf).filter(us.id == ub.BookShelf.shelf).delete()
+            ub.session.query(ub.Shelf).filter(content.id == ub.Shelf.user_id).delete()
            ub.session.query(ub.User).filter(ub.User.id == content.id).delete()
            ub.session_commit()
            log.info(u"User {} deleted".format(content.name))
@@ -1384,6 +1428,8 @@ def _handle_edit_user(to_save, content, languages, translations, kobo_support):
        else:
            content.sidebar_view &= ~constants.DETAIL_RANDOM

+        content.kobo_only_shelves_sync = int(to_save.get("kobo_only_shelves_sync") == "on") or 0
+
        if to_save.get("default_language"):
            content.default_language = to_save["default_language"]
        if to_save.get("locale"):
@@ -1656,7 +1702,13 @@ def get_updater_status():
 def ldap_import_create_user(user, user_data):
    user_login_field = extract_dynamic_field_from_filter(user, config.config_ldap_user_object)

-    username = user_data[user_login_field][0].decode('utf-8')
+    try:
+        username = user_data[user_login_field][0].decode('utf-8')
+    except KeyError as ex:
+        log.error("Failed to extract LDAP user: %s - %s", user, ex)
+        message = _(u'Failed to extract at least One LDAP User')
+        return 0, message
+
    # check for duplicate username
    if ub.session.query(ub.User).filter(func.lower(ub.User.name) == username.lower()).first():
        # if ub.session.query(ub.User).filter(ub.User.name == username).first():
@@ -1754,7 +1806,7 @@ def import_ldap_users():


 def extract_user_data_from_field(user, field):
-    match = re.search(field + r"=([\d\s\w-]+)", user, re.IGNORECASE | re.UNICODE)
+    match = re.search(field + r"=([\.\d\s\w-]+)", user, re.IGNORECASE | re.UNICODE)
    if match:
        return match.group(1)
    else:
@@ -45,7 +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')
+parser.add_argument('-f', action='store_true', help='Flag is depreciated and will be removed in next version')
 args = parser.parse_args()

 if sys.version_info < (3, 0):
@@ -115,5 +115,5 @@ if user_credentials and ":" not in user_credentials:
    print("No valid 'username:password' format")
    sys.exit(3)

-# Handles enabling of filepicker
-filepicker = args.f or None
+if args.f:
+    print("Warning: -f flag is depreciated and will be removed in next version")
@@ -347,7 +347,7 @@ class _ConfigSQL(object):
            log.error(error)
        log.warning("invalidating configuration")
        self.db_configured = False
-        self.config_calibre_dir = None
+        # self.config_calibre_dir = None
        self.save()


@@ -20,6 +20,9 @@ from __future__ import division, print_function, unicode_literals
 import sys
 import os
 from collections import namedtuple
+from sqlalchemy import __version__ as sql_version
+
+sqlalchemy_version2 = ([int(x) for x in sql_version.split('.')] >= [2,0,0])

 # if installed via pip this variable is set to true (empty file with name .HOMEDIR present)
 HOME_CONFIG = os.path.isfile(os.path.join(os.path.dirname(os.path.abspath(__file__)), '.HOMEDIR'))
@@ -154,7 +157,7 @@ def selected_roles(dictionary):
 BookMeta = namedtuple('BookMeta', 'file_path, extension, title, author, cover, description, tags, series, '
                                  'series_id, languages, publisher')

-STABLE_VERSION = {'version': '0.6.12'}
+STABLE_VERSION = {'version': '0.6.13'}

 NIGHTLY_VERSION = {}
 NIGHTLY_VERSION[0] = '$Format:%H$'
@@ -39,9 +39,9 @@ def _get_command_version(path, pattern, argument=None):
        if argument:
            command.append(argument)
        try:
-            for line in process_wait(command):
-                if re.search(pattern, line):
-                    return line
+            match = process_wait(command, pattern=pattern)
+            if isinstance(match, re.Match):
+                return match.string
        except Exception as ex:
            log.warning("%s: %s", path, ex)
            return _EXECUTION_ERROR
@@ -524,19 +524,44 @@ class CalibreDB():
        return cc_classes

    @classmethod
-    def setup_db(cls, config, app_db_path):
+    def check_valid_db(cls, config_calibre_dir, app_db_path):
+        if not config_calibre_dir:
+            return False
+        dbpath = os.path.join(config_calibre_dir, "metadata.db")
+        if not os.path.exists(dbpath):
+            return False
+        try:
+            check_engine = create_engine('sqlite://',
+                          echo=False,
+                          isolation_level="SERIALIZABLE",
+                          connect_args={'check_same_thread': False},
+                          poolclass=StaticPool)
+            with check_engine.begin() as connection:
+                connection.execute(text("attach database '{}' as calibre;".format(dbpath)))
+                connection.execute(text("attach database '{}' as app_settings;".format(app_db_path)))
+            check_engine.connect()
+        except Exception:
+            return False
+        return True
+
+    @classmethod
+    def update_config(cls, config):
        cls.config = config
+
+    @classmethod
+    def setup_db(cls, config_calibre_dir, app_db_path):
+        # cls.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()
+        if not config_calibre_dir:
+            cls.config.invalidate()
            return False

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

        try:
@@ -552,14 +577,14 @@ class CalibreDB():
            conn = cls.engine.connect()
            # conn.text_factory = lambda b: b.decode(errors = 'ignore') possible fix for #1302
        except Exception as ex:
-            config.invalidate(ex)
+            cls.config.invalidate(ex)
            return False

-        config.db_configured = True
+        cls.config.db_configured = True

        if not cc_classes:
            try:
-                cc = conn.execute("SELECT id, datatype FROM custom_columns")
+                cc = conn.execute(text("SELECT id, datatype FROM custom_columns"))
                cls.setup_db_cc_classes(cc)
            except OperationalError as e:
                log.debug_or_exception(e)
@@ -665,6 +690,12 @@ class CalibreDB():
            randm = false()
        off = int(int(pagesize) * (page - 1))
        query = self.session.query(database)
+        if len(join) == 6:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4]).outerjoin(join[5])
+        if len(join) == 5:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4])
+        if len(join) == 4:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3])
        if len(join) == 3:
            query = query.outerjoin(join[0], join[1]).outerjoin(join[2])
        elif len(join) == 2:
@@ -730,6 +761,8 @@ class CalibreDB():
        for authorterm in authorterms:
            q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + authorterm + "%")))
        query = self.session.query(Books)
+        if len(join) == 6:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2]).outerjoin(join[3], join[4]).outerjoin(join[5])
        if len(join) == 3:
            query = query.outerjoin(join[0], join[1]).outerjoin(join[2])
        elif len(join) == 2:
@@ -828,7 +861,8 @@ class CalibreDB():
    def reconnect_db(self, config, app_db_path):
        self.dispose()
        self.engine.dispose()
-        self.setup_db(config, app_db_path)
+        self.setup_db(config.config_calibre_dir, app_db_path)
+        self.update_config(config)


 def lcase(s):
@@ -22,14 +22,10 @@ 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 flask import send_file, __version__

 from . import logger, config
 from .about import collect_stats
@@ -38,14 +34,20 @@ log = logger.create()

 def assemble_logfiles(file_name):
    log_list = sorted(glob.glob(file_name + '*'), reverse=True)
-    wfd = StringIO()
+    wfd = BytesIO()
    for f in log_list:
-        with open(f, 'r') as fd:
+        with open(f, 'rb') as fd:
            shutil.copyfileobj(fd, wfd)
    wfd.seek(0)
-    return send_file(wfd,
-                     as_attachment=True,
-                     attachment_filename=os.path.basename(file_name))
+    if int(__version__.split('.')[0]) < 2:
+        return send_file(wfd,
+                         as_attachment=True,
+                         attachment_filename=os.path.basename(file_name))
+    else:
+        return send_file(wfd,
+                         as_attachment=True,
+                         download_name=os.path.basename(file_name))
+

 def send_debug():
    file_list = glob.glob(logger.get_logfile(config.config_logfile) + '*')
@@ -60,6 +62,11 @@ def send_debug():
        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")
+    if int(__version__.split('.')[0]) < 2:
+        return send_file(memory_zip,
+                         as_attachment=True,
+                         attachment_filename="Calibre-Web-debug-pack.zip")
+    else:
+        return send_file(memory_zip,
+                         as_attachment=True,
+                         download_name="Calibre-Web-debug-pack.zip")
@@ -26,6 +26,19 @@ from datetime import datetime
 import json
 from shutil import copyfile
 from uuid import uuid4
+from markupsafe import escape
+try:
+    from lxml.html.clean import clean_html
+except ImportError:
+    pass
+
+
+# Improve this to check if scholarly is available in a global way, like other pythonic libraries
+try:
+    from scholarly import scholarly
+    have_scholar = True
+except ImportError:
+    have_scholar = False

 from babel import Locale as LC
 from babel.core import UnknownLocaleError
@@ -48,6 +61,8 @@ except ImportError:
    pass  # We're not using Python 3


+
+
 editbook = Blueprint('editbook', __name__)
 log = logger.create()

@@ -450,6 +465,8 @@ def edit_book_series_index(series_index, book):
 # Handle book comments/description
 def edit_book_comments(comments, book):
    modif_date = False
+    if comments:
+        comments = clean_html(comments)
    if len(book.comments):
        if book.comments[0].text != comments:
            book.comments[0].text = comments
@@ -506,6 +523,8 @@ def edit_cc_data_value(book_id, book, c, to_save, cc_db_value, cc_string):
        to_save[cc_string] = 1 if to_save[cc_string] == 'True' else 0
    elif c.datatype == 'comments':
        to_save[cc_string] = Markup(to_save[cc_string]).unescape()
+        if to_save[cc_string]:
+            to_save[cc_string] = clean_html(to_save[cc_string])
    elif c.datatype == 'datetime':
        try:
            to_save[cc_string] = datetime.strptime(to_save[cc_string], "%Y-%m-%d")
@@ -645,9 +664,9 @@ def upload_single_file(request, book, book_id):
                    return redirect(url_for('web.show_book', book_id=book.id))

            # Queue uploader info
-            uploadText=_(u"File format %(ext)s added to %(book)s", ext=file_ext.upper(), book=book.title)
-            WorkerThread.add(current_user.name, TaskUpload(
-                "<a href=\"" + url_for('web.show_book', book_id=book.id) + "\">" + uploadText + "</a>"))
+            link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book.id), escape(book.title))
+            uploadText=_(u"File format %(ext)s added to %(book)s", ext=file_ext.upper(), book=link)
+            WorkerThread.add(current_user.name, TaskUpload(uploadText))

            return uploader.process(
                saved_filename, *os.path.splitext(requested_file.filename),
@@ -1009,7 +1028,7 @@ def upload():
                                                   config.config_calibre_dir,
                                                   input_authors[0],
                                                   meta.file_path,
-                                                   title_dir + meta.extension)
+                                                   title_dir + meta.extension.lower())

                move_coverfile(meta, db_book)

@@ -1020,9 +1039,9 @@ def upload():
                    gdriveutils.updateGdriveCalibreFromLocal()
                if error:
                    flash(error, category="error")
-                uploadText=_(u"File %(file)s uploaded", file=title)
-                WorkerThread.add(current_user.name, TaskUpload(
-                    "<a href=\"" + url_for('web.show_book', book_id=book_id) + "\">" + uploadText + "</a>"))
+                link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book_id), escape(title))
+                uploadText = _(u"File %(file)s uploaded", file=link)
+                WorkerThread.add(current_user.name, TaskUpload(uploadText))

                if len(request.files.getlist("btn-upload")) < 2:
                    if current_user.role_edit() or current_user.role_admin():
@@ -1061,6 +1080,23 @@ def convert_bookformat(book_id):
        flash(_(u"There was an error converting this book: %(res)s", res=rtn), category="error")
    return redirect(url_for('editbook.edit_book', book_id=book_id))

+@editbook.route("/scholarsearch/<query>",methods=['GET'])
+@login_required_if_no_ano
+@edit_required
+def scholar_search(query):
+    if have_scholar:
+        scholar_gen = scholarly.search_pubs(' '.join(query.split('+')))
+        i=0
+        result = []
+        for publication in scholar_gen:
+            del publication['source']
+            result.append(publication)
+            i+=1
+            if(i>=10):
+                break
+        return Response(json.dumps(result),mimetype='application/json')
+    else:
+        return "[]"

@editbook.route("/ajax/editbooks/<param>", methods=['POST'])
@login_required_if_no_ano
@@ -1122,11 +1158,15 @@ def edit_list_book(param):
                                   'newValue':  ' & '.join([author.replace('|',',') for author in input_authors])}),
                       mimetype='application/json')
    book.last_modified = datetime.utcnow()
-    calibre_db.session.commit()
-    # revert change for sort if automatic fields link is deactivated
-    if param == 'title' and vals.get('checkT') == "false":
-        book.sort = sort
+    try:
        calibre_db.session.commit()
+        # revert change for sort if automatic fields link is deactivated
+        if param == 'title' and vals.get('checkT') == "false":
+            book.sort = sort
+            calibre_db.session.commit()
+    except (OperationalError, IntegrityError) as e:
+        calibre_db.session.rollback()
+        log.error("Database error: %s", e)
    return ret


@@ -1198,3 +1238,43 @@ def merge_list_book():
                    delete_book(from_book.id,"", True)
                    return json.dumps({'success': True})
    return ""
+
+@editbook.route("/ajax/xchange", methods=['POST'])
+@login_required
+@edit_required
+def table_xchange_author_title():
+    vals = request.get_json().get('xchange')
+    if vals:
+        for val in vals:
+            modif_date = False
+            book = calibre_db.get_book(val)
+            authors = book.title
+            entries = calibre_db.order_authors(book)
+            author_names = []
+            for authr in entries.authors:
+                author_names.append(authr.name.replace('|', ','))
+
+            title_change = handle_title_on_edit(book, " ".join(author_names))
+            input_authors, authorchange = handle_author_on_edit(book, authors)
+            if authorchange or title_change:
+                edited_books_id = book.id
+                modif_date = True
+
+            if config.config_use_google_drive:
+                gdriveutils.updateGdriveCalibreFromLocal()
+
+            if edited_books_id:
+                helper.update_dir_stucture(edited_books_id, config.config_calibre_dir, input_authors[0])
+            if modif_date:
+                book.last_modified = datetime.utcnow()
+            try:
+                calibre_db.session.commit()
+            except (OperationalError, IntegrityError) as e:
+                calibre_db.session.rollback()
+                log.error("Database error: %s", e)
+                return json.dumps({'success': False})
+
+            if config.config_use_google_drive:
+                gdriveutils.updateGdriveCalibreFromLocal()
+        return json.dumps({'success': True})
+    return ""
@@ -35,6 +35,7 @@ def error_http(error):
                           error_code="Error {0}".format(error.code),
                           error_name=error.name,
                           issue=False,
+                           unconfigured=not config.db_configured,
                           instance=config.config_calibre_web_title
                           ), error.code

@@ -44,6 +45,7 @@ def internal_error(error):
                           error_code="Internal Server Error",
                           error_name=str(error),
                           issue=True,
+                           unconfigured=False,
                           error_stack=traceback.format_exc().split("\n"),
                           instance=config.config_calibre_web_title
                           ), 500
@@ -74,7 +74,7 @@ def google_drive_callback():
            f.write(credentials.to_json())
    except (ValueError, AttributeError) as error:
        log.error(error)
-    return redirect(url_for('admin.configuration'))
+    return redirect(url_for('admin.db_configuration'))


@gdrive.route("/watch/subscribe")
@@ -99,7 +99,7 @@ def watch_gdrive():
            else:
                flash(reason['message'], category="error")

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


@gdrive.route("/watch/revoke")
@@ -115,7 +115,7 @@ def revoke_watch_gdrive():
            pass
        config.config_google_drive_watch_changes_response = {}
        config.save()
-    return redirect(url_for('admin.configuration'))
+    return redirect(url_for('admin.db_configuration'))


@gdrive.route("/watch/callback", methods=['GET', 'POST'])
@@ -34,6 +34,7 @@ try:
 except ImportError:
    from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.exc import OperationalError, InvalidRequestError
+from sqlalchemy.sql.expression import text

 try:
    from apiclient import errors
@@ -168,7 +169,7 @@ class PermissionAdded(Base):
 def migrate():
    if not engine.dialect.has_table(engine.connect(), "permissions_added"):
        PermissionAdded.__table__.create(bind = engine)
-    for sql in session.execute("select sql from sqlite_master where type='table'"):
+    for sql in session.execute(text("select sql from sqlite_master where type='table'")):
        if 'CREATE TABLE gdrive_ids' in sql[0]:
            currUniqueConstraint = 'UNIQUE (gdrive_id)'
            if currUniqueConstraint in sql[0]:
@@ -38,6 +38,7 @@ from flask_login import current_user
 from sqlalchemy.sql.expression import true, false, and_, text, func
 from werkzeug.datastructures import Headers
 from werkzeug.security import generate_password_hash
+from markupsafe import escape

 try:
    from urllib.parse import quote
@@ -97,10 +98,11 @@ def convert_book_format(book_id, calibrepath, old_book_format, new_book_format,
        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>"))
+    link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book.id), escape(book.title))  # prevent xss
+    txt = u"{} -> {}: {}".format(
+           old_book_format.upper(),
+           new_book_format.upper(),
+           link)
    settings['old_book_format'] = old_book_format
    settings['new_book_format'] = new_book_format
    WorkerThread.add(user_id, TaskConvert(file_path, book.id, txt, settings, kindle_mail, user_id))
@@ -214,9 +216,11 @@ def send_mail(book_id, book_format, convert, kindle_mail, calibrepath, user_id):
    for entry in iter(book.data):
        if entry.format.upper() == book_format.upper():
            converted_file_name = entry.name + '.' + book_format.lower()
+            link = '<a href="{}">{}</a>'.format(url_for('web.show_book', book_id=book_id), escape(book.title))
+            EmailText = _(u"%(book)s send to Kindle", book=link)
            WorkerThread.add(user_id, TaskEmail(_(u"Send to Kindle"), book.path, converted_file_name,
                             config.get_mail_settings(), kindle_mail,
-                             _(u"E-mail: %(book)s", book=book.title), _(u'This e-mail has been sent via Calibre-Web.')))
+                             EmailText, _(u'This e-mail has been sent via Calibre-Web.')))
            return
    return _(u"The requested file could not be read. Maybe wrong permissions?")

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


 # Moves files in file storage during author/title rename, or from temp dir to file storage
@@ -382,7 +387,7 @@ def update_dir_structure_file(book_id, calibrepath, first_author, orignal_filepa
                            # 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:
+        except (OSError) as ex:
            log.error("Rename title from: %s to %s: %s", path, new_path, ex)
            log.debug(ex, exc_info=True)
            return _("Rename title from: '%(src)s' to '%(dest)s' failed with error: %(error)s",
@@ -397,7 +402,7 @@ def update_dir_structure_file(book_id, calibrepath, first_author, orignal_filepa
                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:
+        except (OSError) as ex:
            log.error("Rename file in path %s to %s: %s", new_path, new_name, ex)
            log.debug(ex, exc_info=True)
            return _("Rename file in path '%(src)s' to '%(dest)s' failed with error: %(error)s",
@@ -710,12 +715,11 @@ def check_unrar(unrarLocation):
        if sys.version_info < (3, 0):
            unrarLocation = unrarLocation.encode(sys.getfilesystemencoding())
        unrarLocation = [unrarLocation]
-        for lines in process_wait(unrarLocation):
-            value = re.search('UNRAR (.*) freeware', lines, re.IGNORECASE)
-            if value:
-                version = value.group(1)
-                log.debug("unrar version %s", version)
-                break
+        value = process_wait(unrarLocation, pattern='UNRAR (.*) freeware')
+        if value:
+            version = value.group(1)
+            log.debug("unrar version %s", version)
+
    except (OSError, UnicodeDecodeError) as err:
        log.debug_or_exception(err)
        return _('Error excecuting UnRar')
@@ -778,7 +782,7 @@ def render_task_status(tasklist):

            ret['taskMessage'] = "{}: {}".format(_(task.name), task.message)
            ret['progress'] = "{} %".format(int(task.progress * 100))
-            ret['user'] = user
+            ret['user'] = escape(user)  # prevent xss
            renderedtasklist.append(ret)

    return renderedtasklist
@@ -972,6 +972,8 @@ LANGUAGE_NAMES = {
        "gor": "Gorontalo",
        "got": "Γοτθικά",
        "grb": "Grebo",
+        "grc": "Ελληνικά; Αρχαία (to 1453)",
+        "ell": "Ελληνικά; Μοντέρνα (1453-)",
        "grn": "Guarani",
        "guj": "Gujarati",
        "gwi": "Gwichʼin",
@@ -31,7 +31,7 @@ from babel.dates import format_date
 from flask import Blueprint, request, url_for
 from flask_babel import get_locale
 from flask_login import current_user
-
+from markupsafe import escape
 from . import logger


@@ -113,10 +113,8 @@ def yesno(value, yes, no):

@jinjia.app_template_filter('formatfloat')
 def formatfloat(value, decimals=1):
-    formatedstring = '%d' % value
-    if (value % 1) != 0:
-        formatedstring = ('%s.%d' % (formatedstring, (value % 1) * 10**decimals)).rstrip('0')
-    return formatedstring
+    value = 0 if not value else value
+    return ('{0:.' + str(decimals) + 'f}').format(value).rstrip('0').rstrip('.')


@jinjia.app_template_filter('formatseriesindex')
@@ -131,6 +129,10 @@ def formatseriesindex_filter(series_index):
            return series_index
    return 0

+@jinjia.app_template_filter('escapedlink')
+def escapedlink_filter(url, text):
+    return "<a href='{}'>{}</a>".format(url, escape(text))
+
@jinjia.app_template_filter('uuidfilter')
 def uuidfilter(var):
    return uuid4()
@@ -42,11 +42,13 @@ from flask import (
 from flask_login import current_user
 from werkzeug.datastructures import Headers
 from sqlalchemy import func
-from sqlalchemy.sql.expression import and_
+from sqlalchemy.sql.expression import and_, or_
 from sqlalchemy.exc import StatementError
+from sqlalchemy.sql import select
 import requests

 from . import config, logger, kobo_auth, db, calibre_db, helper, shelf as shelf_lib, ub
+from .constants import sqlalchemy_version2
 from .helper import get_download_link
 from .services import SyncToken as SyncToken
 from .web import download_required
@@ -81,6 +83,7 @@ CONNECTION_SPECIFIC_HEADERS = [
    "transfer-encoding",
 ]

+
 def get_kobo_activated():
    return config.config_kobo_sync

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

@@ -151,32 +155,57 @@ def HandleSyncRequest():
    # in case of external changes (e.g: adding a book through Calibre).
    calibre_db.reconnect_db(config, ub.app_DB_path)

-    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))
-            .filter(calibre_db.common_filters())
-            .order_by(db.Books.last_modified)
-            .order_by(db.Books.id)
-            .limit(SYNC_ITEM_LIMIT)
+    only_kobo_shelves = current_user.kobo_only_shelves_sync
+
+    if only_kobo_shelves:
+        if sqlalchemy_version2:
+            changed_entries = select(db.Books,
+                                     ub.ArchivedBook.last_modified,
+                                     ub.BookShelf.date_added,
+                                     ub.ArchivedBook.is_archived)
+        else:
+            changed_entries = calibre_db.session.query(db.Books,
+                                                       ub.ArchivedBook.last_modified,
+                                                       ub.BookShelf.date_added,
+                                                       ub.ArchivedBook.is_archived)
+        changed_entries = (changed_entries
+                .join(db.Data).outerjoin(ub.ArchivedBook, db.Books.id == ub.ArchivedBook.book_id)
+                .filter(or_(db.Books.last_modified > sync_token.books_last_modified,
+                            ub.BookShelf.date_added > sync_token.books_last_modified))
+                .filter(db.Data.format.in_(KOBO_FORMATS)).filter(calibre_db.common_filters())
+                .order_by(db.Books.id)
+                .order_by(ub.ArchivedBook.last_modified)
+                .join(ub.BookShelf, db.Books.id == ub.BookShelf.book_id)
+                .join(ub.Shelf)
+                .filter(ub.Shelf.user_id == current_user.id)
+                .filter(ub.Shelf.kobo_sync)
+                .distinct()
        )
    else:
-        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))
-            .filter(calibre_db.common_filters())
-            .order_by(db.Books.last_modified)
-            .order_by(db.Books.id)
-            .limit(SYNC_ITEM_LIMIT)
+        if sqlalchemy_version2:
+            changed_entries = select(db.Books, ub.ArchivedBook.last_modified, ub.ArchivedBook.is_archived)
+        else:
+            changed_entries = calibre_db.session.query(db.Books,
+                                                       ub.ArchivedBook.last_modified,
+                                                       ub.ArchivedBook.is_archived)
+        changed_entries = (changed_entries
+                .join(db.Data).outerjoin(ub.ArchivedBook, db.Books.id == ub.ArchivedBook.book_id)
+                .filter(db.Books.last_modified > sync_token.books_last_modified)
+                .filter(calibre_db.common_filters())
+                .filter(db.Data.format.in_(KOBO_FORMATS))
+                .order_by(db.Books.last_modified)
+                .order_by(db.Books.id)
        )

+    if sync_token.books_last_id > -1:
+        changed_entries = changed_entries.filter(db.Books.id > sync_token.books_last_id)
+
    reading_states_in_new_entitlements = []
-    for book in changed_entries:
+    if sqlalchemy_version2:
+        books = calibre_db.session.execute(changed_entries.limit(SYNC_ITEM_LIMIT))
+    else:
+        books = changed_entries.limit(SYNC_ITEM_LIMIT)
+    for book in books:
        formats = [data.format for data in book.Books.data]
        if not 'KEPUB' in formats and config.config_kepubifypath and 'EPUB' in formats:
            helper.convert_book_format(book.Books.id, config.config_calibre_dir, 'EPUB', 'KEPUB', current_user.name)
@@ -192,7 +221,14 @@ def HandleSyncRequest():
            new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified)
            reading_states_in_new_entitlements.append(book.Books.id)

-        if book.Books.timestamp > sync_token.books_last_created:
+        ts_created = book.Books.timestamp
+
+        try:
+            ts_created = max(ts_created, book.date_added)
+        except AttributeError:
+            pass
+
+        if ts_created > sync_token.books_last_created:
            sync_results.append({"NewEntitlement": entitlement})
        else:
            sync_results.append({"ChangedEntitlement": entitlement})
@@ -200,35 +236,59 @@ def HandleSyncRequest():
        new_books_last_modified = max(
            book.Books.last_modified, new_books_last_modified
        )
-        new_books_last_created = max(book.Books.timestamp, new_books_last_created)
+        try:
+            new_books_last_modified = max(
+                new_books_last_modified, book.date_added
+            )
+        except AttributeError:
+            pass

-    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
+        new_books_last_created = max(ts_created, new_books_last_created)
+
+    if sqlalchemy_version2:
+        max_change = calibre_db.session.execute(changed_entries
+                                                .filter(ub.ArchivedBook.is_archived)
+                                                .order_by(func.datetime(ub.ArchivedBook.last_modified).desc()))\
+            .columns(db.Books).first()
    else:
-        max_change = new_archived_last_modified
+        max_change = changed_entries.from_self().filter(ub.ArchivedBook.is_archived) \
+            .order_by(func.datetime(ub.ArchivedBook.last_modified).desc()).first()
+
+    max_change = max_change.last_modified if max_change else new_archived_last_modified
+
    new_archived_last_modified = max(new_archived_last_modified, max_change)

    # no. of books returned
-    book_count = changed_entries.count()
-
-    # last entry:
-    if book_count:
-        books_last_id = changed_entries.all()[-1].Books.id or -1
+    if sqlalchemy_version2:
+        entries = calibre_db.session.execute(changed_entries).all()
+        book_count = len(entries)
    else:
-        books_last_id = -1
+        entries = changed_entries.all()
+        book_count = changed_entries.count()
+    # last entry:
+    books_last_id = entries[-1].Books.id or -1 if book_count else -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))))
+    changed_reading_states = ub.session.query(ub.KoboReadingState)
+
+    if only_kobo_shelves:
+        changed_reading_states = changed_reading_states.join(ub.BookShelf,
+                                                             ub.KoboReadingState.book_id == ub.BookShelf.book_id)\
+            .join(ub.Shelf)\
+            .filter(current_user.id == ub.Shelf.user_id)\
+            .filter(ub.Shelf.kobo_sync,
+                    or_(
+                        func.datetime(ub.KoboReadingState.last_modified) > sync_token.reading_state_last_modified,
+                        func.datetime(ub.BookShelf.date_added) > sync_token.books_last_modified
+                    )).distinct()
+    else:
+        changed_reading_states = changed_reading_states.filter(
+            func.datetime(ub.KoboReadingState.last_modified) > sync_token.reading_state_last_modified)
+
+    changed_reading_states = changed_reading_states.filter(
+        and_(ub.KoboReadingState.user_id == current_user.id,
+             ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements)))
+
    for kobo_reading_state in changed_reading_states.all():
        book = calibre_db.session.query(db.Books).filter(db.Books.id == kobo_reading_state.book_id).one_or_none()
        if book:
@@ -239,7 +299,7 @@ def HandleSyncRequest():
            })
            new_reading_state_last_modified = max(new_reading_state_last_modified, kobo_reading_state.last_modified)

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

    sync_token.books_last_created = new_books_last_created
    sync_token.books_last_modified = new_books_last_modified
@@ -270,6 +330,7 @@ def generate_sync_response(sync_token, sync_results, set_cont=False):
        extra_headers["x-kobo-sync"] = "continue"
    sync_token.to_headers(extra_headers)

+    log.debug("Kobo Sync Content: {}".format(sync_results))
    response = make_response(jsonify(sync_results), extra_headers)

    return response
@@ -394,7 +455,7 @@ def get_metadata(book):

    book_uuid = book.uuid
    metadata = {
-        "Categories": ["00000000-0000-0000-0000-000000000001",],
+        "Categories": ["00000000-0000-0000-0000-000000000001", ],
        # "Contributors": get_author(book),
        "CoverImageId": book_uuid,
        "CrossRevisionId": book_uuid,
@@ -601,13 +662,14 @@ def HandleTagRemoveItem(tag_id):

 # Add new, changed, or deleted shelves to the sync_results.
 # Note: Public shelves that aren't owned by the user aren't supported.
-def sync_shelves(sync_token, sync_results):
+def sync_shelves(sync_token, sync_results, only_kobo_shelves=False):
    new_tags_last_modified = sync_token.tags_last_modified

-    for shelf in ub.session.query(ub.ShelfArchive).filter(func.datetime(ub.ShelfArchive.last_modified) > sync_token.tags_last_modified,
-                                                          ub.ShelfArchive.user_id == current_user.id):
+    for shelf in ub.session.query(ub.ShelfArchive).filter(
+        func.datetime(ub.ShelfArchive.last_modified) > sync_token.tags_last_modified,
+        ub.ShelfArchive.user_id == current_user.id
+    ):
        new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified)
-
        sync_results.append({
            "DeletedTag": {
                "Tag": {
@@ -617,8 +679,40 @@ def sync_shelves(sync_token, sync_results):
            }
        })

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

@@ -183,3 +183,12 @@ class SyncToken:
            },
        }
        return b64encode_json(token)
+
+    def __str__(self):
+        return "{},{},{},{},{},{},{}".format(self.raw_kobo_store_token,
+                                       self.books_last_created,
+                                       self.books_last_modified,
+                                       self.archive_last_modified,
+                                       self.reading_state_last_modified,
+                                       self.tags_last_modified,
+                                       self.books_last_id)
@@ -61,7 +61,7 @@ def get_user_info(credentials):
    return user_info.get('email', "")

 def send_messsage(token, msg):
-    log.debug("Start sending email via Gmail")
+    log.debug("Start sending e-mail via Gmail")
    creds = Credentials(
        token=token['token'],
        refresh_token=token['refresh_token'],
@@ -80,4 +80,4 @@ def send_messsage(token, msg):
    body = {'raw': raw}

    (service.users().messages().send(userId='me', body=body).execute())
-    log.debug("Email send successfully via Gmail")
+    log.debug("E-mail send successfully via Gmail")
@@ -21,20 +21,20 @@
 #  along with this program. If not, see <http://www.gnu.org/licenses/>.

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

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

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

-
 shelf = Blueprint('shelf', __name__)
 log = logger.create()

@@ -72,10 +72,9 @@ def add_to_shelf(shelf_id, book_id):

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

    book_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id,
                                                          ub.BookShelf.book_id == book_id).first()
@@ -228,38 +227,42 @@ def remove_from_shelf(shelf_id, book_id):
@login_required
 def create_shelf():
    shelf = ub.Shelf()
-    return create_edit_shelf(shelf, title=_(u"Create a Shelf"), page="shelfcreate")
+    return create_edit_shelf(shelf, page_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 not check_shelf_edit_permissions(shelf):
+        flash(_(u"Sorry you are not allowed to edit this shelf"), category="error")
+        return redirect(url_for('web.index'))
+    return create_edit_shelf(shelf, page_title=_(u"Edit a shelf"), page="shelfedit", shelf_id=shelf_id)


 # if shelf ID is set, we are editing a shelf
-def create_edit_shelf(shelf, title, page, shelf_id=False):
+def create_edit_shelf(shelf, page_title, page, shelf_id=False):
+    sync_only_selected_shelves = current_user.kobo_only_shelves_sync
+    # calibre_db.session.query(ub.Shelf).filter(ub.Shelf.user_id == current_user.id).filter(ub.Shelf.kobo_sync).count()
    if request.method == "POST":
        to_save = request.form.to_dict()
-        if "is_public" in to_save:
-            shelf.is_public = 1
-        else:
-            shelf.is_public = 0
-        if check_shelf_is_unique(shelf, to_save, shelf_id):
-            shelf.name = to_save["title"]
-            # shelf.last_modified = datetime.utcnow()
+        shelf.is_public = 1 if to_save.get("is_public") else 0
+        if config.config_kobo_sync:
+            shelf.kobo_sync = True if to_save.get("kobo_sync") else False
+        shelf_title = to_save.get("title", "")
+        if check_shelf_is_unique(shelf, shelf_title, shelf_id):
+            shelf.name = shelf_title
            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"])
+                flash_text = _(u"Shelf %(title)s created", title=shelf_title)
            else:
                shelf_action = "changed"
-                flash_text = _(u"Shelf %(title)s changed", title=to_save["title"])
+                flash_text = _(u"Shelf %(title)s changed", title=shelf_title)
            try:
                ub.session.commit()
-                log.info(u"Shelf {} {}".format(to_save["title"], shelf_action))
+                log.info(u"Shelf {} {}".format(shelf_title, shelf_action))
                flash(flash_text, category="success")
                return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id))
            except (OperationalError, InvalidRequestError) as ex:
@@ -271,34 +274,39 @@ def create_edit_shelf(shelf, title, page, shelf_id=False):
                ub.session.rollback()
                log.debug_or_exception(ex)
                flash(_(u"There was an error"), category="error")
-    return render_title_template('shelf_edit.html', shelf=shelf, title=title, page=page)
+    return render_title_template('shelf_edit.html',
+                                 shelf=shelf,
+                                 title=page_title,
+                                 page=page,
+                                 kobo_sync_enabled=config.config_kobo_sync,
+                                 sync_only_selected_shelves=sync_only_selected_shelves)


-def check_shelf_is_unique(shelf, to_save, shelf_id=False):
+def check_shelf_is_unique(shelf, title, shelf_id=False):
    if shelf_id:
        ident = ub.Shelf.id != shelf_id
    else:
        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((ub.Shelf.name == title) & (ub.Shelf.is_public == 1)) \
                                   .filter(ident) \
                                   .first() is None

        if not is_shelf_name_unique:
-            log.error("A public shelf with the name '{}' already exists.".format(to_save["title"]))
-            flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]),
+            log.error("A public shelf with the name '{}' already exists.".format(title))
+            flash(_(u"A public shelf with the name '%(title)s' already exists.", title=title),
                  category="error")
    else:
        is_shelf_name_unique = ub.session.query(ub.Shelf) \
-                                   .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) &
+                                   .filter((ub.Shelf.name == title) & (ub.Shelf.is_public == 0) &
                                           (ub.Shelf.user_id == int(current_user.id))) \
                                   .filter(ident) \
                                   .first() is None

        if not is_shelf_name_unique:
-            log.error("A private shelf with the name '{}' already exists.".format(to_save["title"]))
-            flash(_(u"A private shelf with the name '%(title)s' already exists.", title=to_save["title"]),
+            log.error("A private shelf with the name '{}' already exists.".format(title))
+            flash(_(u"A private shelf with the name '%(title)s' already exists.", title=title),
                  category="error")
    return is_shelf_name_unique

@@ -362,8 +370,8 @@ def order_shelf(shelf_id):
    shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
    result = list()
    if shelf and check_shelf_view_permissions(shelf):
-        result = calibre_db.session.query(db.Books)\
-            .join(ub.BookShelf,ub.BookShelf.book_id == db.Books.id , isouter=True) \
+        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,
@@ -372,7 +380,9 @@ def order_shelf(shelf_id):


 def change_shelf_order(shelf_id, order):
-    result = calibre_db.session.query(db.Books).join(ub.BookShelf,ub.BookShelf.book_id == db.Books.id)\
+    result = calibre_db.session.query(db.Books).outerjoin(db.books_series_link,
+                                                          db.Books.id == db.books_series_link.c.book)\
+        .outerjoin(db.Series).join(ub.BookShelf, ub.BookShelf.book_id == db.Books.id) \
        .filter(ub.BookShelf.shelf == shelf_id).order_by(*order).all()
    for index, entry in enumerate(result):
        book = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \
@@ -402,9 +412,11 @@ def render_show_shelf(shelf_type, shelf_id, page_no, sort_param):
            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()])
+                change_shelf_order(shelf_id, [db.Books.author_sort.asc(), db.Series.name, db.Books.series_index])
            if sort_param == 'authza':
-                change_shelf_order(shelf_id, [db.Books.author_sort.desc()])
+                change_shelf_order(shelf_id, [db.Books.author_sort.desc(),
+                                              db.Series.name.desc(),
+                                              db.Books.series_index.desc()])
            page = "shelf.html"
            pagesize = 0
        else:
@@ -412,13 +424,13 @@ def render_show_shelf(shelf_type, shelf_id, page_no, sort_param):
            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)
+                                                           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)\
+        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))
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEáCNS2-H
@@ -0,0 +1,3 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSEá	ETen-B5-H` ^
@@ -0,0 +1,4 @@
+àRCopyright 1990-2009 Adobe Systems Incorporated.
+All rights reserved.
+See ./LICENSE!!�º]aX!!]`�21�>	�p�z�$]‚�"R‚d�-Uƒ7�*„
4„%�+ „Z „{�/…%…<�9K…b�1]†.�"‡‰`]‡,�"]ˆ
+�"]ˆh�"]‰F�"]Š$�"]‹�"]‹`�"]Œ>�"]��"]�z�"]ŽX�"]�6�"]��"]�r�"]‘P�"]’.�"]“�"]“j�"]”H�"]•&�"]–�"]–b�"]—@�"]˜�"]˜|�"]™Z�"]š8�"]›�"]›t�"]œR�"]�0�"]ž�"]žl�"]ŸJ�"] (�"]¡�"]¡d�"]¢B�"]£ �"X£~�']¤W�"]¥5�"]¦�"]¦q�"]§O�"]¨-�"]©�"]©i�"]ªG�"]«%�"]¬�"]¬a�"]?�"]®�"]®{�"]¯Y�"]°7�"]±�"]±s�"]²Q�"]³/�"]´
�"]´k�"]µI�"]¶'�"]·�"]·c�"]¸A�"]¹�"]¹}�"]º[�"]»9
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ozzie Isaacs	2edcd16119	Update version to 0.6.13 for release	2021-09-25 08:34:20 +02:00
Ozzie Isaacs	af202bd6d1	Merge remote-tracking branch 'pt_br/patch-1'	2021-09-25 08:25:06 +02:00
Ozzie Isaacs	d5a332a84e	Update test results	2021-09-25 08:23:14 +02:00
Fernando Mesquita	d6884164a5	Update messages.po Read = Leia > Lido	2021-09-25 01:07:31 -03:00
Ozzie Isaacs	356a4f588e	Merge remote-tracking branch 'nl/master'	2021-09-22 20:43:29 +02:00
Ozzie Isaacs	241b31458d	Added ancient and modern Greek translation to greek language	2021-09-22 20:34:18 +02:00
Ozzie Isaacs	efb04ddd8f	Fix #2061 (Defective utf-16 txt files)	2021-09-22 19:58:20 +02:00
Jeroen Hellingman	6f6d8df431	Update messages.po Review of Dutch translations (native speaker); improving consistency in vocabulary still needed.	2021-09-02 11:25:58 +02:00
Ozzie Isaacs	42ef049b63	Catch error on ldap import	2021-08-30 20:17:56 +02:00
Ozzie Isaacs	ceffa3a108	Removed xss on shelf add/remove action	2021-08-30 17:06:11 +02:00
Ozzie Isaacs	d8bad7394a	Merge remote-tracking branch 'caliblur/master'	2021-08-29 13:31:46 +02:00
Ozzie Isaacs	f5062d1354	Merge remote-tracking branch 'it/patch-1'	2021-08-29 13:31:21 +02:00
Ozzie Isaacs	1d79d9ded2	Bugfix from tests (displaying of book languages in user list)	2021-08-29 11:31:10 +02:00
Ozzie Isaacs	1fa267ce1b	Final fix for escaping html special chars in tables	2021-08-28 15:47:57 +02:00
Ozzie Isaacs	d4cfad6363	Fixed several text problems from tasks Fixed task update	2021-08-28 11:32:13 +02:00
Ozzie Isaacs	3a24561ca2	Removed additional " from convert message	2021-08-28 10:32:40 +02:00
Ozzie Isaacs	5c19a8aacc	Bugfix edit comments Testupdate	2021-08-28 08:24:38 +02:00
Ozzie Isaacs	7ae3255ea9	Revert Content-Security-Policy header	2021-08-27 14:28:30 +02:00
Ozzie Isaacs	91e6d94c83	Improved displaying of username and task title in tasks	2021-08-27 14:27:35 +02:00
Ozzie Isaacs	e615073893	Add all html special characters to the escaped characters in bootstrap table	2021-08-27 12:56:08 +02:00
Ozzie Isaacs	32e27712f0	Added lxml to needed requirements Improved displaying of series title, book of series, comments and custom comments	2021-08-27 09:43:32 +02:00
Daniela Mazza	80d3ba42b4	Update messages.po Changed translate of "Read Books": the meaning is exactly "Libri letti", not "Libri da leggere"	2021-08-26 19:16:38 +02:00
Ozzie Isaacs	d25cfb7499	Fix for #2097 (Quotes are now handled properly in UI-editable tables)	2021-08-26 18:03:59 +02:00
cbartondock	24ad15be11	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-08-19 08:30:13 -04:00
Ozzie Isaacs	afa585eb65	Added -f flag for compatibility reasons	2021-08-18 20:32:13 +02:00
cbartondock	03acb77162	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-08-15 12:06:55 -04:00
Ozzie Isaacs	28ca39ca13	Add logging of user sessions	2021-08-15 12:43:19 +02:00
cbartondock	b05c17b8bb	Fixed book covers being too wide in search/shelves/discover on mobile	2021-08-14 21:50:05 -04:00
cbartondock	3839af65c4	add python-version to gitignore for managed pyenv compatibility	2021-08-14 15:57:09 -04:00
Ozzie Isaacs	275e073c42	Fix #2085 (Missing spaces between glyphicon and text on sidebar)	2021-08-10 20:17:30 +02:00
Ozzie Isaacs	c4876010e9	Merge remote-tracking branch 'pdf/master'	2021-08-09 16:46:19 +02:00
xlivevil	bce69b2dfc	Add pdf.js font file	2021-08-07 20:51:10 +08:00
xlivevil	fb97e39d9f	Merge branch 'master' of https://github.com/xlivevil/calibre-web	2021-08-05 21:39:04 +08:00
xlivevil	913690df78	Fix #1913(set lazyload in pdf reader) Add favicon.ico in pdf reader	2021-08-05 21:37:39 +08:00
Ozzie Isaacs	1534827ad7	With merge button disabled it's no longer possible to open merge dialog	2021-08-01 20:23:04 +02:00
Ozzie Isaacs	b36422bc05	Update list/grid button action (reverse proxy problem)	2021-08-01 20:06:48 +02:00
Ozzie Isaacs	1e2335dea0	Merge remote-tracking branch 'caliblur/master'	2021-08-01 17:35:30 +02:00
Ozzie Isaacs	e052590270	Merge remote-tracking branch 'chinese/master' # Conflicts: # cps/translations/zh_Hans_CN/LC_MESSAGES/messages.mo # cps/translations/zh_Hans_CN/LC_MESSAGES/messages.po # messages.pot	2021-08-01 17:31:47 +02:00
Ozzie Isaacs	41ca85268f	Update translation files	2021-08-01 17:27:18 +02:00
Ozzie Isaacs	0e9709f304	Make Book-No. of book-range to translatable text	2021-08-01 17:09:29 +02:00
cbartondock	81ccc11c9c	fixed dropdowns going off screen in caliblur	2021-07-31 12:51:51 -04:00
Ozzie Isaacs	16633ef1d3	Fix #2029 (Import LDAP User with "." in the name)	2021-07-30 20:45:33 +02:00
Ozzie Isaacs	a32b36bf81	Fixed missing joins for sorting according to series in read/unread and rated views	2021-07-30 16:58:20 +02:00
Ozzie Isaacs	a63baa1758	better logged in session protection	2021-07-30 16:28:37 +02:00
cbartondock	752192a057	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-30 09:34:50 -04:00
Ozzie Isaacs	e245a147d9	Revert accidentally committed store user session	2021-07-30 10:16:52 +02:00
Ozzie Isaacs	0ec2bcd897	Fixes from testrun	2021-07-30 09:25:19 +02:00
xlivevil	19c75d6790	Update Simplified Chinese translation	2021-07-29 14:00:02 +08:00
cbartondock	0654156dd6	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-27 11:24:23 -04:00
Ziding Zhang	e4b0434733	Create SECURITY.md A simple instruction for security researchers in future.	2021-07-27 13:22:24 +02:00
cbartondock	b32721c293	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-27 06:39:29 -04:00
Ozzie Isaacs	c5e39a7523	Fix divs in user edit page	2021-07-27 08:09:57 +02:00
cbartondock	0db837c0ce	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-26 14:44:16 -04:00
Ozzie Isaacs	53dae32897	Fix multiple messages on windows after change config with reboot	2021-07-26 16:50:21 +02:00
Ozzie Isaacs	018f3ca250	Sort authors additionally to series and series_index (Fix #2001 ) Sqlalchemy version2 is now a global flag	2021-07-26 07:52:01 +02:00
Ozzie Isaacs	f9c3e751f6	Fixes for handling shelf requests without title	2021-07-24 05:49:16 +02:00
Ozzie Isaacs	c7b057ec51	Merge remote-tracking branch 'shelf_edit/security_fixes' into master	2021-07-24 05:34:24 +02:00
Ozzie Isaacs	85ea762054	Handle shelf request without title	2021-07-24 05:33:51 +02:00
Ozzie Isaacs	56cd62ed90	Fix show edit user after exception	2021-07-23 20:12:37 +02:00
Ozzie Isaacs	9a8c342e61	Fix deleting user (deleting shelfs and so on failed before)	2021-07-23 20:03:20 +02:00
Ozzie Isaacs	3b81ea37f4	Fix entries of user table are visible if database has no tags	2021-07-23 19:46:01 +02:00
Ozzie Isaacs	3c8bfc31e4	fix change name allowd as non admin	2021-07-23 19:34:46 +02:00
Ileana Maricel Barrionuevo	59881367fe	Security fixes: Report 85176e1f-7920-4824-87ea-8eb5b5e505e0: Exposure of Private Personal Information to an Unauthorized Actor in janeczku/calibre-web	2021-07-22 01:05:11 -03:00
Ileana Maricel Barrionuevo	c8ebaee0f7	Security fix improved: user should not edit other shelve's titles	2021-07-22 00:41:07 -03:00
Ileana Maricel Barrionuevo	d5d0ad50fa	Fixed security issue: a user could edit others' shelves.	2021-07-21 22:08:41 -03:00
cbartondock	6ef792d65d	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-12 12:08:55 -04:00
Ozzie Isaacs	20fa9f5523	Fix encoding errors on windows while downloading logbooks	2021-07-12 17:33:35 +02:00
Ozzie Isaacs	616cc2018a	Fix show cover Update more debug output for kobo sync	2021-07-12 14:58:03 +02:00
Ozzie Isaacs	e69b1adccd	Fix #2053 (Add tooltip for complete title on hover over cover and title)	2021-07-12 14:17:28 +02:00
Ozzie Isaacs	280efad939	#2052 (wrong series index shown for series_index >=100)	2021-07-12 14:04:23 +02:00
Ozzie Isaacs	15ec6bec95	fix #2014 (User menu dropdown in caliblur is tiny and presents scrollbars) Fix display of nonexistent series_index Fix caliblur add-to-shelf	2021-07-11 13:15:13 +02:00
Ozzie Isaacs	aae81c3d24	Fix #2048 (Display book title in reader)	2021-07-11 12:52:46 +02:00
Ozzie Isaacs	1bf065fd04	Bugfix with encoding errors windows	2021-07-11 07:38:15 +02:00
Ozzie Isaacs	f8de7e75cc	Fix error unclosed IO on external binary version query	2021-07-11 09:19:46 +02:00
Ozzie Isaacs	87f07003f4	Removed invalid code Sqlalchemy 2.0 compatibility for kobo sync	2021-07-11 08:49:47 +02:00
cbartondock	7d586b3745	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-10 13:21:27 -04:00
Ozzie Isaacs	a56e071a19	Fix #2043 (Multiuser kobo sync with restrict to shelfs working) Sync only selected shelfs is stored correct on creating user	2021-07-10 17:09:04 +02:00
Ozzie Isaacs	480aecb16c	Fix #2046 (Deleting book with additional "/" in database path is working)	2021-07-10 08:27:29 +02:00
cbartondock	91938fd18a	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-07-08 15:52:14 -04:00
Ozzie Isaacs	305e75c0ae	Clarification for pip command	2021-07-07 16:42:05 +02:00
Ozzie Isaacs	47d94d9bd6	Search metadata without installed google scholar working (fix #2024 )	2021-06-29 18:38:02 +02:00
Ozzie Isaacs	a6d1f6039d	Merge remote-tracking branch 'es/spanish-translation' into master # Conflicts: # cps/translations/es/LC_MESSAGES/messages.po	2021-06-29 18:30:37 +02:00
Ozzie Isaacs	31234a4b98	Merge remote-tracking branch 'fr/Update-French-transations' into master # Conflicts: # cps/translations/fr/LC_MESSAGES/messages.po	2021-06-29 18:25:57 +02:00
Ozzie Isaacs	476275ea53	Merge remote-tracking branch 'po/master' into master # Conflicts: # cps/translations/pl/LC_MESSAGES/messages.po	2021-06-29 18:25:25 +02:00
Ozzie Isaacs	792d4a65bc	Fix typo	2021-06-29 18:24:35 +02:00
Ozzie Isaacs	0e2dca5f4d	Fix upload of books uppercase extensions (#2038 )	2021-06-26 20:14:52 +02:00
JFernando122	2236191263	Fixing typos on spanish translation	2021-06-22 23:37:19 -05:00
JFernando122	1138c86868	improved spanish translation with adrocampo's review	2021-06-22 14:22:28 -05:00
Thomas	08500c66a8	Update French translations The French translation is normally completely now	2021-06-19 16:01:25 +02:00
JFernando122	fa03a9ee25	Updated spanish translation	2021-06-17 21:49:04 -05:00
cbartondock	bf4564e365	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-06-13 21:38:25 -04:00
Radoslaw Kierznowski	6a96664381	Update translations	2021-06-12 15:41:48 +02:00
Ozzie Isaacs	e6e3032f02	Merge remote-tracking branch 'pl/master' into master	2021-06-12 08:52:14 +02:00
Ozzie Isaacs	6d424f0a30	Merge remote-tracking branch 'nl/patch-1' into master	2021-06-12 08:50:51 +02:00
Ozzie Isaacs	a6f0375db3	Merge remote-tracking branch 'it/patch-25' into master	2021-06-12 08:50:13 +02:00
Radoslaw Kierznowski	70151c2e11	Update Translations	2021-06-10 15:23:12 +02:00
JVT038	ab69962e8a	Completed Translation for Dutch (NL)	2021-06-09 20:26:09 +02:00
ElQuimm	075fe994af	Update italian message.po Updated version	2021-06-08 21:11:36 +02:00
Ozzie Isaacs	93e8c5be32	Fixes for flask version 2.1 Fixes for compatibility with sqlalchemy 2.0	2021-06-05 18:41:42 +02:00
Ozzie Isaacs	d9f86aecd2	Fix change_permission	2021-06-05 13:51:16 +02:00
Ozzie Isaacs	84e1c6e809	Fix for #2004 (pdf viewer buttons missing in safari)	2021-06-05 08:08:08 +02:00
Ozzie Isaacs	aadd6fd7e0	Possible fix for #2003 (Calibre theme download icon broken)	2021-06-03 12:35:09 +02:00
Ozzie Isaacs	a79600c81f	Mass change book title and author (fix #1996 )	2021-05-28 18:22:29 +02:00
Ozzie Isaacs	e8a4c3c6b9	Merge remote-tracking branch 'shields/patch-3' into master	2021-05-28 17:46:53 +02:00
Ozzie Isaacs	62fce26651	Bugfix extended search term with excluded series/shelfs	2021-05-28 14:57:35 +02:00
Ozzie Isaacs	25add6511f	Catch error on search for new custom column (created after start of calibre-web)	2021-05-28 14:54:18 +02:00
Ozzie Isaacs	b2a28cd39a	Merge branch 'Develop' into master	2021-05-28 14:23:47 +02:00
Ozzie Isaacs	6de3aebf3a	Fix for #1998 (Error 500 with configured oauth on user setup page accessed by admins)	2021-05-28 14:23:30 +02:00
Ozzie Isaacs	1b7e422772	Changed error page to display logout route in case of unconfigured	2021-05-28 13:56:07 +02:00
Ozzie Isaacs	b0f48b7f00	Merge branch 'master' into Develop	2021-05-26 19:58:10 +02:00
Ozzie Isaacs	94b07d05c1	First half of #1996 (editing single books)	2021-05-26 19:57:58 +02:00
Ozzie Isaacs	4392fec7f5	Added fullscreen cover viewer	2021-05-26 19:40:41 +02:00
flying-sausages	c1d0ec076b	Shield cleanup	2021-05-26 17:20:54 +02:00
Ozzie Isaacs	a47d6cd937	Fix confirm dialog database change Gdrive setup basically working again Moved basicconfig behind login Database setup separated from other setup Config page is using ajax (flask >2 and slow computers)	2021-05-26 14:50:44 +02:00
Ozzie Isaacs	dcdb5e2a9e	Merge branch 'master' into Develop	2021-05-22 19:52:53 +02:00
Ozzie Isaacs	240325dc18	Update installation instructions	2021-05-22 19:52:20 +02:00
Ozzie Isaacs	e599d2ec05	Merge remote-tracking branch 'scholar/master' into master	2021-05-22 19:30:57 +02:00
Ozzie Isaacs	c62a417cbf	Merge branch 'Develop' into master	2021-05-22 19:29:58 +02:00
Ozzie Isaacs	98fc1ee0a7	Comic reader code cleaning	2021-05-22 19:28:30 +02:00
Ozzie Isaacs	78d0fd811b	Version bump	2021-05-22 14:57:55 +02:00
Ozzie Isaacs	a62fca1e55	Merge branch 'master' into Develop	2021-05-22 11:28:59 +02:00
cbartondock	1b2124aa35	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-05-19 16:47:19 -04:00
Ozzie Isaacs	010c0bfc7d	Improved error handling for content too long	2021-05-16 14:07:16 +02:00
Ozzie Isaacs	251780bed6	Added google scholar as metadata provider	2021-05-16 13:24:42 +02:00
Ozzie Isaacs	decc2a9c79	Merge branch 'master' into Develop	2021-05-16 13:19:38 +02:00
Ozzie Isaacs	e15324d2cd	Merge branch 'master' into Develop	2021-05-16 09:38:00 +02:00
Ozzie Isaacs	109198a374	Merge branch 'master' into Develop	2021-05-16 09:03:58 +02:00
Ozzie Isaacs	3e5c944365	Changed backend for comic reader, now supports rar5	2021-05-16 08:35:20 +02:00
Ozzie Isaacs	d95838309e	Added config option for shelf sync behavior	2021-05-15 10:45:51 +02:00
Ozzie Isaacs	b3648187ff	Bugfix search for publishdates and custom column dates Bugfix save umplauts in comments unescaped (as calibre does) Improved testability	2021-05-15 07:51:12 +02:00
cbartondock	b35483edf8	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-05-14 23:31:05 -04:00
Ozzie Isaacs	f29088e854	Merge branch 'master' into Develop # Conflicts: # cps/kobo.py	2021-05-14 19:59:35 +02:00
cbartondock	e0fac8d2c0	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-05-13 11:25:59 -04:00
cbartondock	0a65c05083	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-05-07 09:05:27 -04:00
Ozzieisaacs	eb2273247f	Changed texts in edit shelf page for Kobo shelf sync	2021-05-02 15:59:40 +02:00
Ozzieisaacs	02fc698f1c	Some little code refactoring	2021-05-02 10:05:25 +02:00
Ozzieisaacs	8dc11e89bd	Merge remote-tracking branch 'koko_sync/feature/kobo-shelf' into Develop	2021-05-02 09:43:47 +02:00
cbartondock	12c3264000	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-05-01 21:55:09 -04:00
Ozzieisaacs	b34672ed19	Merge branch 'master' into Develop	2021-05-01 20:54:01 +02:00
cbartondock	f2cd93dc54	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-29 10:01:18 -04:00
cbartondock	c2c4636961	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-28 08:43:44 -04:00
cbartondock	c2e530af17	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-26 13:49:25 -04:00
cbartondock	577b525508	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-26 10:23:24 -04:00
cbartondock	541dd6b579	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-22 18:12:19 -04:00
cbartondock	e57229e670	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-22 12:22:45 -04:00
cbartondock	1ef2a96465	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-19 12:20:54 -04:00
cbartondock	85f1ca6101	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-15 08:43:28 -04:00
cbartondock	2f3f13afb9	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-14 09:30:05 -04:00
cbartondock	e15ebd5aac	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-12 19:02:26 -04:00
cbartondock	ff99cd2456	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-11 16:26:55 -04:00
cbartondock	df91ca500f	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-08 20:25:02 -04:00
cbartondock	eb599373ee	prevented dropdowns from going off screen in caliblur	2021-04-06 13:21:36 -04:00
cbartondock	7b529b5f9e	merge remote	2021-04-06 13:05:55 -04:00
cbartondock	389f0ae452	Merge branch 'master' of https://github.com/janeczku/calibre-web	2021-04-02 10:41:25 -04:00
cbartondock	00a24756f4	get rid of ugly outline on hover over book	2021-04-01 14:06:24 -04:00
cbartondock	9025f312cc	Fixed read in browser button in caliblur theme	2021-04-01 13:53:53 -04:00
cbartondock	d5e453edd3	added scholarly to libraries in about page	2021-03-31 22:43:23 -04:00
cbartondock	26cc64bdd6	Use google scholar to fetch metadata	2021-03-31 22:16:00 -04:00
alfred82santa	24bbf226a1	Sync reading state only for books on kobo shelves	2021-03-14 11:29:23 +01:00
alfred82santa	6014b04b2a	Use BookShelf added_date as date reference	2021-02-08 20:10:12 +01:00
alfred82santa	2b7c1345ee	Fix disable shelf kobo sync	2021-02-07 00:21:51 +01:00
alfred82santa	69b7d94774	Fixes and remove shelf kobo sync flag when kobo sync disabled	2021-02-07 00:19:24 +01:00
alfred82santa	8fe762709b	Fix mistake	2021-02-06 21:15:36 +01:00
alfred82santa	a3f17deb17	Added options in order to synchronize only selected shelf on Kobo device	2021-02-06 20:29:43 +01:00