Merge branch 'master' into Develop

cps/cli.py

@@ -71,7 +71,7 @@ def version_info():
     if os.path.isfile(args.c):
         certfilepath = args.c
     else:
-        print("Certfilepath is invalid. Exiting...")
+        print("Certfile path is invalid. Exiting...")
         sys.exit(1)
 
 if args.c == "":
@@ -81,7 +81,7 @@ def version_info():
     if os.path.isfile(args.k):
         keyfilepath = args.k
     else:
-        print("Keyfilepath is invalid. Exiting...")
+        print("Keyfile path is invalid. Exiting...")
         sys.exit(1)
 
 if (args.k and not args.c) or (not args.k and args.c):
@@ -91,29 +91,29 @@ def version_info():
 if args.k == "":
     keyfilepath = ""
 
-# handle and check ipadress argument
-ipadress = args.i or None
-if ipadress:
+# handle and check ip address argument
+ip_address = args.i or None
+if ip_address:
     try:
         # try to parse the given ip address with socket
         if hasattr(socket, 'inet_pton'):
-            if ':' in ipadress:
-                socket.inet_pton(socket.AF_INET6, ipadress)
+            if ':' in ip_address:
+                socket.inet_pton(socket.AF_INET6, ip_address)
             else:
-                socket.inet_pton(socket.AF_INET, ipadress)
+                socket.inet_pton(socket.AF_INET, ip_address)
         else:
             # on windows python < 3.4, inet_pton is not available
             # inet_atom only handles IPv4 addresses
-            socket.inet_aton(ipadress)
+            socket.inet_aton(ip_address)
     except socket.error as err:
-        print(ipadress, ':', err)
+        print(ip_address, ':', err)
         sys.exit(1)
 
 # handle and check user password argument
 user_credentials = args.s or None
 if user_credentials and ":" not in user_credentials:
-    print("No valid username:password format")
+    print("No valid 'username:password' format")
     sys.exit(3)
 
-# Handles enableing of filepicker
+# Handles enabling of filepicker
 filepicker = args.f or None

cps/config_sql.py

@@ -20,16 +20,18 @@
 from __future__ import division, print_function, unicode_literals
 import os
 import sys
+import json
 
-from sqlalchemy import exc, Column, String, Integer, SmallInteger, Boolean, BLOB, JSON
+from sqlalchemy import Column, String, Integer, SmallInteger, Boolean, BLOB, JSON
 from sqlalchemy.exc import OperationalError
+from sqlalchemy.sql.expression import text
 try:
-    # Compability with sqlalchemy 2.0
+    # Compatibility with sqlalchemy 2.0
     from sqlalchemy.orm import declarative_base
 except ImportError:
     from sqlalchemy.ext.declarative import declarative_base
 
-from . import constants, cli, logger, ub
+from . import constants, cli, logger
 
 
 log = logger.create()
@@ -190,7 +192,7 @@ def get_config_keyfile(self):
 
     @staticmethod
     def get_config_ipaddress():
-        return cli.ipadress or ""
+        return cli.ip_address or ""
 
     def _has_role(self, role_flag):
         return constants.has_flag(self.config_default_role, role_flag)
@@ -260,7 +262,6 @@ def set_from_dictionary(self, dictionary, field, convertor=None, default=None, e
         """
         new_value = dictionary.get(field, default)
         if new_value is None:
-            # log.debug("_ConfigSQL set_from_dictionary field '%s' not found", field)
             return False
 
         if field not in self.__dict__:
@@ -277,7 +278,6 @@ def set_from_dictionary(self, dictionary, field, convertor=None, default=None, e
         if current_value == new_value:
             return False
 
-        # log.debug("_ConfigSQL set_from_dictionary '%s' = %r (was %r)", field, new_value, current_value)
         setattr(self, field, new_value)
         return True
 
@@ -358,7 +358,7 @@ def _migrate_table(session, orm_class):
         if column_name[0] != '_':
             try:
                 session.query(column).first()
-            except exc.OperationalError as err:
+            except OperationalError as err:
                 log.debug("%s: %s", column_name, err.args[0])
                 if column.default is not None:
                     if sys.version_info < (3, 0):
@@ -368,20 +368,23 @@ def _migrate_table(session, orm_class):
                     column_default = ""
                 else:
                     if isinstance(column.default.arg, bool):
-                        column_default = ("DEFAULT %r" % int(column.default.arg))
+                        column_default = "DEFAULT {}".format(int(column.default.arg))
                     else:
-                        column_default = ("DEFAULT '%r'" % column.default.arg)
+                        column_default = "DEFAULT `{}`".format(column.default.arg)
                 if isinstance(column.type, JSON):
                     column_type = "JSON"
                 else:
                     column_type = column.type
-                alter_table = "ALTER TABLE %s ADD COLUMN `%s` %s %s" % (orm_class.__tablename__,
+                alter_table = text("ALTER TABLE %s ADD COLUMN `%s` %s %s" % (orm_class.__tablename__,
                                                                         column_name,
                                                                         column_type,
-                                                                        column_default)
+                                                                        column_default))
                 log.debug(alter_table)
                 session.execute(alter_table)
                 changed = True
+            except json.decoder.JSONDecodeError as e:
+                log.error("Database corrupt column: {}".format(column_name))
+                log.debug(e)
 
     if changed:
         try:

cps/db.py

@@ -33,7 +33,7 @@
 from sqlalchemy.ext.declarative import DeclarativeMeta
 from sqlalchemy.exc import OperationalError
 try:
-    # Compability with sqlalchemy 2.0
+    # Compatibility with sqlalchemy 2.0
     from sqlalchemy.orm import declarative_base
 except ImportError:
     from sqlalchemy.ext.declarative import declarative_base
@@ -44,6 +44,7 @@
 from babel import Locale as LC
 from babel.core import UnknownLocaleError
 from flask_babel import gettext as _
+from flask import flash
 
 from . import logger, ub, isoLanguages
 from .pagination import Pagination
@@ -121,6 +122,8 @@ def formatType(self):
             return u"Douban"
         elif format_type == "goodreads":
             return u"Goodreads"
+        elif format_type == "babelio":
+            return u"Babelio"
         elif format_type == "google":
             return u"Google Books"
         elif format_type == "kobo":
@@ -148,6 +151,8 @@ def __repr__(self):
             return u"https://dx.doi.org/{0}".format(self.val)
         elif format_type == "goodreads":
             return u"https://www.goodreads.com/book/show/{0}".format(self.val)
+        elif format_type == "babelio":
+            return u"https://www.babelio.com/livres/titre/{0}".format(self.val)
         elif format_type == "douban":
             return u"https://book.douban.com/subject/{0}".format(self.val)
         elif format_type == "google":
@@ -393,7 +398,7 @@ def default(self, o):
         if isinstance(o.__class__, DeclarativeMeta):
             # an SQLAlchemy class
             fields = {}
-            for field in [x for x in dir(o) if not x.startswith('_') and x != 'metadata']:
+            for field in [x for x in dir(o) if not x.startswith('_') and x != 'metadata' and x!="password"]:
                 if field == 'books':
                     continue
                 data = o.__getattribute__(field)
@@ -602,20 +607,46 @@ def common_filters(self, allow_show_archived=False):
         neg_content_tags_filter = false() if negtags_list == [''] else Books.tags.any(Tags.name.in_(negtags_list))
         pos_content_tags_filter = true() if postags_list == [''] else Books.tags.any(Tags.name.in_(postags_list))
         if self.config.config_restricted_column:
-            pos_cc_list = current_user.allowed_column_value.split(',')
-            pos_content_cc_filter = true() if pos_cc_list == [''] else \
-                getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
-                    any(cc_classes[self.config.config_restricted_column].value.in_(pos_cc_list))
-            neg_cc_list = current_user.denied_column_value.split(',')
-            neg_content_cc_filter = false() if neg_cc_list == [''] else \
-                getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
-                    any(cc_classes[self.config.config_restricted_column].value.in_(neg_cc_list))
+            try:
+                pos_cc_list = current_user.allowed_column_value.split(',')
+                pos_content_cc_filter = true() if pos_cc_list == [''] else \
+                    getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
+                        any(cc_classes[self.config.config_restricted_column].value.in_(pos_cc_list))
+                neg_cc_list = current_user.denied_column_value.split(',')
+                neg_content_cc_filter = false() if neg_cc_list == [''] else \
+                    getattr(Books, 'custom_column_' + str(self.config.config_restricted_column)). \
+                        any(cc_classes[self.config.config_restricted_column].value.in_(neg_cc_list))
+            except (KeyError, AttributeError):
+                pos_content_cc_filter = false()
+                neg_content_cc_filter = true()
+                log.error(u"Custom Column No.%d is not existing in calibre database",
+                          self.config.config_restricted_column)
+                flash(_("Custom Column No.%(column)d is not existing in calibre database",
+                        column=self.config.config_restricted_column),
+                      category="error")
+
         else:
             pos_content_cc_filter = true()
             neg_content_cc_filter = false()
         return and_(lang_filter, pos_content_tags_filter, ~neg_content_tags_filter,
                     pos_content_cc_filter, ~neg_content_cc_filter, archived_filter)
 
+    @staticmethod
+    def get_checkbox_sorted(inputlist, state, offset, limit, order):
+        outcome = list()
+        elementlist = {ele.id: ele for ele in inputlist}
+        for entry in state:
+            try:
+                outcome.append(elementlist[entry])
+            except KeyError:
+                pass
+            del elementlist[entry]
+        for entry in elementlist:
+            outcome.append(elementlist[entry])
+        if order == "asc":
+            outcome.reverse()
+        return outcome[offset:offset + limit]
+
     # Fill indexpage with all requested data from database
     def fill_indexpage(self, page, pagesize, database, db_filter, order, *join):
         return self.fill_indexpage_with_archived_books(page, pagesize, database, db_filter, order, False, *join)
@@ -689,23 +720,33 @@ def check_exists_book(self, authr, title):
         return self.session.query(Books) \
             .filter(and_(Books.authors.any(and_(*q)), func.lower(Books.title).ilike("%" + title + "%"))).first()
 
-    # read search results from calibre-database and return it (function is used for feed and simple search
-    def get_search_results(self, term, offset=None, order=None, limit=None):
-        order = order or [Books.sort]
-        pagination = None
+    def search_query(self, term, *join):
         term.strip().lower()
         self.session.connection().connection.connection.create_function("lower", 1, lcase)
         q = list()
         authorterms = re.split("[, ]+", term)
         for authorterm in authorterms:
             q.append(Books.authors.any(func.lower(Authors.name).ilike("%" + authorterm + "%")))
-        result = self.session.query(Books).filter(self.common_filters(True)).filter(
+        query = self.session.query(Books)
+        if len(join) == 3:
+            query = query.outerjoin(join[0], join[1]).outerjoin(join[2])
+        elif len(join) == 2:
+            query = query.outerjoin(join[0], join[1])
+        elif len(join) == 1:
+            query = query.outerjoin(join[0])
+        return query.filter(self.common_filters(True)).filter(
             or_(Books.tags.any(func.lower(Tags.name).ilike("%" + term + "%")),
                 Books.series.any(func.lower(Series.name).ilike("%" + term + "%")),
                 Books.authors.any(and_(*q)),
                 Books.publishers.any(func.lower(Publishers.name).ilike("%" + term + "%")),
                 func.lower(Books.title).ilike("%" + term + "%")
-                )).order_by(*order).all()
+                ))
+
+    # read search results from calibre-database and return it (function is used for feed and simple search
+    def get_search_results(self, term, offset=None, order=None, limit=None, *join):
+        order = order or [Books.sort]
+        pagination = None
+        result = self.search_query(term, *join).order_by(*order).all()
         result_count = len(result)
         if offset != None and limit != None:
             offset = int(offset)

cps/editbooks.py

@@ -229,14 +229,14 @@ def modify_identifiers(input_identifiers, db_identifiers, db_session):
 @editbook.route("/ajax/delete/<int:book_id>")
 @login_required
 def delete_book_from_details(book_id):
-    return Response(delete_book(book_id,"", True), mimetype='application/json')
+    return Response(delete_book(book_id, "", True), mimetype='application/json')
 
 
 @editbook.route("/delete/<int:book_id>", defaults={'book_format': ""})
 @editbook.route("/delete/<int:book_id>/<string:book_format>")
 @login_required
 def delete_book_ajax(book_id, book_format):
-    return delete_book(book_id,book_format, False)
+    return delete_book(book_id, book_format, False)
 
 
 def delete_whole_book(book_id, book):
@@ -315,19 +315,19 @@ def delete_book(book_id, book_format, jsonResponse):
                 result, error = helper.delete_book(book, config.config_calibre_dir, book_format=book_format.upper())
                 if not result:
                     if jsonResponse:
-                        return json.dumps({"location": url_for("editbook.edit_book"),
-                                           "type": "alert",
+                        return json.dumps([{"location": url_for("editbook.edit_book", book_id=book_id),
+                                           "type": "danger",
                                            "format": "",
-                                           "error": error}),
+                                           "message": error}])
                     else:
                         flash(error, category="error")
                         return redirect(url_for('editbook.edit_book', book_id=book_id))
                 if error:
                     if jsonResponse:
-                        warning = {"location": url_for("editbook.edit_book"),
+                        warning = {"location": url_for("editbook.edit_book", book_id=book_id),
                                                 "type": "warning",
                                                 "format": "",
-                                                "error": error}
+                                                "message": error}
                     else:
                         flash(error, category="warning")
                 if not book_format:
@@ -339,6 +339,15 @@ def delete_book(book_id, book_format, jsonResponse):
             except Exception as ex:
                 log.debug_or_exception(ex)
                 calibre_db.session.rollback()
+                if jsonResponse:
+                    return json.dumps([{"location": url_for("editbook.edit_book", book_id=book_id),
+                                        "type": "danger",
+                                        "format": "",
+                                        "message": ex}])
+                else:
+                    flash(str(ex), category="error")
+                    return redirect(url_for('editbook.edit_book', book_id=book_id))
+
         else:
             # book not found
             log.error('Book with id "%s" could not be deleted: not found', book_id)
@@ -1176,6 +1185,6 @@ def merge_list_book():
                                                         element.format,
                                                         element.uncompressed_size,
                                                         to_name))
-                    delete_book(from_book.id,"", True) # json_resp =
+                    delete_book(from_book.id,"", True)
                     return json.dumps({'success': True})
     return ""