Bugfixes from testrun

cps/admin.py

@@ -863,10 +863,10 @@ def delete_restriction(res_type, user_id):
             usr = current_user
         if element['id'].startswith('a'):
             usr.allowed_tags = restriction_deletion(element, usr.list_allowed_tags)
-            ub.session_commit("Deleted allowed tags of user {}: {}".format(usr.name, usr.list_allowed_tags))
+            ub.session_commit("Deleted allowed tags of user {}: {}".format(usr.name, element['Element']))
         elif element['id'].startswith('d'):
             usr.denied_tags = restriction_deletion(element, usr.list_denied_tags)
-            ub.session_commit("Deleted denied tags of user {}: {}".format(usr.name, usr.list_allowed_tags))
+            ub.session_commit("Deleted denied tag of user {}: {}".format(usr.name, element['Element']))
     elif res_type == 3:  # Columns per user
         if isinstance(user_id, int):
             usr = ub.session.query(ub.User).filter(ub.User.id == int(user_id)).first()
@@ -875,12 +875,12 @@ def delete_restriction(res_type, user_id):
         if element['id'].startswith('a'):
             usr.allowed_column_value = restriction_deletion(element, usr.list_allowed_column_values)
             ub.session_commit("Deleted allowed columns of user {}: {}".format(usr.name,
-                                                                              usr.list_allowed_column_values))
+                                                                              usr.list_allowed_column_values()))
 
         elif element['id'].startswith('d'):
             usr.denied_column_value = restriction_deletion(element, usr.list_denied_column_values)
             ub.session_commit("Deleted denied columns of user {}: {}".format(usr.name,
-                                                                             usr.list_denied_column_values))
+                                                                             usr.list_denied_column_values()))
     return ""
 
 

cps/opds.py

@@ -26,7 +26,7 @@ from functools import wraps
 
 from flask import Blueprint, request, render_template, Response, g, make_response, abort
 from flask_login import current_user
-from sqlalchemy.sql.expression import func, text, or_, and_, true
+from sqlalchemy.sql.expression import func, text, or_, and_, any_, true
 from werkzeug.security import check_password_hash
 from . import constants, logger, config, db, calibre_db, ub, services, get_locale, isoLanguages
 from .helper import get_download_link, get_book_cover
@@ -34,7 +34,7 @@ from .pagination import Pagination
 from .web import render_read_books
 from .usermanagement import load_user_from_request
 from flask_babel import gettext as _
-
+from sqlalchemy.orm import InstrumentedAttribute
 opds = Blueprint('opds', __name__)
 
 log = logger.create()
@@ -298,7 +298,7 @@ def feed_ratingindex():
 @opds.route("/opds/ratings/<book_id>")
 @requires_basic_auth_if_no_ano
 def feed_ratings(book_id):
-    return render_xml_dataset(db.Tags, book_id)
+    return render_xml_dataset(db.Ratings, book_id)
 
 
 @opds.route("/opds/formats")
@@ -493,7 +493,7 @@ def render_xml_dataset(data_table, book_id):
     off = request.args.get("offset") or 0
     entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
                                                         db.Books,
-                                                        data_table.any(data_table.id == book_id),
+                                                        getattr(db.Books, data_table.__tablename__).any(data_table.id == book_id),
                                                         [db.Books.timestamp.desc()])
     return render_xml_template('feed.xml', entries=entries, pagination=pagination)
 
@@ -502,7 +502,7 @@ def render_element_index(database_column, linked_table, folder):
     shift = 0
     off = int(request.args.get("offset") or 0)
     entries = calibre_db.session.query(func.upper(func.substr(database_column, 1, 1)).label('id'))
-    if linked_table:
+    if linked_table is not None:
         entries = entries.join(linked_table).join(db.Books)
     entries = entries.filter(calibre_db.common_filters()).group_by(func.upper(func.substr(database_column, 1, 1))).all()
     elements = []

cps/web.py

@@ -1129,27 +1129,6 @@ def adv_search_custom_columns(cc, term, q):
     return q
 
 
-def adv_search_language(q, include_languages_inputs, exclude_languages_inputs):
-    if current_user.filter_language() != "all":
-        q = q.filter(db.Books.languages.any(db.Languages.lang_code == current_user.filter_language()))
-    else:
-        for language in include_languages_inputs:
-            q = q.filter(db.Books.languages.any(db.Languages.id == language))
-        for language in exclude_languages_inputs:
-            q = q.filter(not_(db.Books.series.any(db.Languages.id == language)))
-    return q
-
-
-def adv_search_ratings(q, rating_high, rating_low):
-    if rating_high:
-        rating_high = int(rating_high) * 2
-        q = q.filter(db.Books.ratings.any(db.Ratings.rating <= rating_high))
-    if rating_low:
-        rating_low = int(rating_low) * 2
-        q = q.filter(db.Books.ratings.any(db.Ratings.rating >= rating_low))
-    return q
-
-
 def adv_search_read_status(q, read_status):
     if read_status:
         if config.config_read_column:
@@ -1178,38 +1157,32 @@ def adv_search_read_status(q, read_status):
     return q
 
 
-def adv_search_text(q, include_inputs, exclude_inputs, data_value):
+def adv_search_language(q, include_languages_inputs, exclude_languages_inputs):
+    if current_user.filter_language() != "all":
+        q = q.filter(db.Books.languages.any(db.Languages.lang_code == current_user.filter_language()))
+    else:
+        return adv_search_text(q, include_languages_inputs, exclude_languages_inputs, db.Languages.id)
+    return q
+
+
+def adv_search_ratings(q, rating_high, rating_low):
+    if rating_high:
+        rating_high = int(rating_high) * 2
+        q = q.filter(db.Books.ratings.any(db.Ratings.rating <= rating_high))
+    if rating_low:
+        rating_low = int(rating_low) * 2
+        q = q.filter(db.Books.ratings.any(db.Ratings.rating >= rating_low))
+    return q
+
+
+def adv_search_text(q, include_inputs, exclude_inputs, data_table):
     for inp in include_inputs:
-        q = q.filter(db.Books.data.any(data_value == inp))
+        q = q.filter(getattr(db.Books, data_table.class_.__tablename__).any(data_table == inp))
     for excl in exclude_inputs:
-        q = q.filter(not_(db.Books.data.any(data_value == excl)))
+        q = q.filter(not_(getattr(db.Books, data_table.class_.__tablename__).any(data_table == excl)))
     return q
 
 
-'''def adv_search_extension(q, include_extension_inputs, exclude_extension_inputs):
-    for extension in include_extension_inputs:
-        q = q.filter(db.Books.data.any(db.Data.format == extension))
-    for extension in exclude_extension_inputs:
-        q = q.filter(not_(db.Books.data.any(db.Data.format == extension)))
-    return q
-
-
-def adv_search_tag(q, include_tag_inputs, exclude_tag_inputs):
-    for tag in include_tag_inputs:
-        q = q.filter(db.Books.tags.any(db.Tags.id == tag))
-    for tag in exclude_tag_inputs:
-        q = q.filter(not_(db.Books.tags.any(db.Tags.id == tag)))
-    return q
-
-
-def adv_search_serie(q, include_series_inputs, exclude_series_inputs):
-    for serie in include_series_inputs:
-        q = q.filter(db.Books.series.any(db.Series.id == serie))
-    for serie in exclude_series_inputs:
-        q = q.filter(not_(db.Books.series.any(db.Series.id == serie)))
-    return q'''
-
-
 def adv_search_shelf(q, include_shelf_inputs, exclude_shelf_inputs):
     q = q.outerjoin(ub.BookShelf, db.Books.id == ub.BookShelf.book_id) \
         .filter(or_(ub.BookShelf.shelf == None, ub.BookShelf.shelf.notin_(exclude_shelf_inputs)))
@@ -1376,7 +1349,7 @@ def render_adv_search_results(term, offset=None, order=None, limit=None):
         q = adv_search_text(q, tags['include_serie'], tags['exclude_serie'], db.Series.id)
         q = adv_search_text(q, tags['include_extension'], tags['exclude_extension'], db.Data.format)
         q = adv_search_shelf(q, tags['include_shelf'], tags['exclude_shelf'])
-        q = adv_search_language(q, tags['include_language'], tags['exclude_language'], )
+        q = adv_search_language(q, tags['include_language'], tags['exclude_language'])
         q = adv_search_ratings(q, rating_high, rating_low, )
 
         if description: