mirrors/calibre-web
1
0
Fork 0
mirror of https://github.com/janeczku/calibre-web synced 2024-11-24 18:47:23 +00:00
Code Issues Releases Wiki Activity

Changed session_handing

Browse Source
This commit is contained in:
Ozzieisaacs 2020-12-07 08:44:49 +01:00
parent c25afdc203
commit 777c2726d3
13 changed files with 254 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
cps/__init__.py
View File

@ -71,7 +71,7 @@ lm.session_protection = 'strong'
ub.init_db(cli.settingspath) ub.init_db(cli.settingspath)
# pylint: disable=no-member # pylint: disable=no-member
config = config_sql.load_configuration(ub.session) config = config_sql.load_configuration(ub.Scoped_Session)
web_server = WebServer() web_server = WebServer()
@ -94,12 +94,13 @@ def create_app():
app.root_path = app.root_path.decode('utf-8') app.root_path = app.root_path.decode('utf-8')
app.instance_path = app.instance_path.decode('utf-8') app.instance_path = app.instance_path.decode('utf-8')
#if os.environ.get('FLASK_DEBUG'):
cache_buster.init_cache_busting(app) cache_buster.init_cache_busting(app)
log.info('Starting Calibre Web...') log.info('Starting Calibre Web...')
Principal(app) Principal(app)
lm.init_app(app) lm.init_app(app)
app.secret_key = os.getenv('SECRET_KEY', config_sql.get_flask_session_key(ub.session)) app.secret_key = os.getenv('SECRET_KEY', config_sql.get_flask_session_key(ub.Scoped_Session))
web_server.init_app(app, config) web_server.init_app(app, config)

112
cps/admin.py
View File

@ -30,7 +30,7 @@ from datetime import datetime, timedelta
from babel import Locale as LC from babel import Locale as LC
from babel.dates import format_datetime from babel.dates import format_datetime
from flask import Blueprint, flash, redirect, url_for, abort, request, make_response, send_from_directory from flask import Blueprint, flash, redirect, url_for, abort, request, make_response, send_from_directory, g
from flask_login import login_required, current_user, logout_user from flask_login import login_required, current_user, logout_user
from flask_babel import gettext as _ from flask_babel import gettext as _
from sqlalchemy import and_ from sqlalchemy import and_
@ -88,7 +88,7 @@ def shutdown():
if task in (0, 1): # valid commandos received if task in (0, 1): # valid commandos received
# close all database connections # close all database connections
calibre_db.dispose() calibre_db.dispose()
ub.dispose() # ub.dispose()
if task == 0: if task == 0:
showtext['text'] = _(u'Server restarted, please reload page') showtext['text'] = _(u'Server restarted, please reload page')
@ -130,7 +130,7 @@ def admin():
else: else:
commit = version['version'] commit = version['version']
allUser = ub.session.query(ub.User).all() allUser = g.ubsession.query(ub.User).all()
email_settings = config.get_mail_settings() email_settings = config.get_mail_settings()
kobo_support = feature_support['kobo'] and config.config_kobo_sync kobo_support = feature_support['kobo'] and config.config_kobo_sync
return render_title_template("admin.html", allUser=allUser, email=email_settings, config=config, commit=commit, return render_title_template("admin.html", allUser=allUser, email=email_settings, config=config, commit=commit,
@ -204,9 +204,9 @@ def edit_domain(allow):
# pk: 1 //primary key (record id) # pk: 1 //primary key (record id)
# value: 'superuser!' //new value # value: 'superuser!' //new value
vals = request.form.to_dict() vals = request.form.to_dict()
answer = ub.session.query(ub.Registration).filter(ub.Registration.id == vals['pk']).first() answer = g.ubsession.query(ub.Registration).filter(ub.Registration.id == vals['pk']).first()
answer.domain = vals['value'].replace('*', '%').replace('?', '_').lower() answer.domain = vals['value'].replace('*', '%').replace('?', '_').lower()
ub.session.commit() g.ubsession.commit()
return "" return ""
@ -215,12 +215,12 @@ def edit_domain(allow):
@admin_required @admin_required
def add_domain(allow): def add_domain(allow):
domain_name = request.form.to_dict()['domainname'].replace('*', '%').replace('?', '_').lower() domain_name = request.form.to_dict()['domainname'].replace('*', '%').replace('?', '_').lower()
check = ub.session.query(ub.Registration).filter(ub.Registration.domain == domain_name)\ check = g.ubsession.query(ub.Registration).filter(ub.Registration.domain == domain_name)\
.filter(ub.Registration.allow == allow).first() .filter(ub.Registration.allow == allow).first()
if not check: if not check:
new_domain = ub.Registration(domain=domain_name, allow=allow) new_domain = ub.Registration(domain=domain_name, allow=allow)
ub.session.add(new_domain) g.ubsession.add(new_domain)
ub.session.commit() g.ubsession.commit()
return "" return ""
@ -229,13 +229,13 @@ def add_domain(allow):
@admin_required @admin_required
def delete_domain(): def delete_domain():
domain_id = request.form.to_dict()['domainid'].replace('*', '%').replace('?', '_').lower() domain_id = request.form.to_dict()['domainid'].replace('*', '%').replace('?', '_').lower()
ub.session.query(ub.Registration).filter(ub.Registration.id == domain_id).delete() g.ubsession.query(ub.Registration).filter(ub.Registration.id == domain_id).delete()
ub.session.commit() g.ubsession.commit()
# If last domain was deleted, add all domains by default # If last domain was deleted, add all domains by default
if not ub.session.query(ub.Registration).filter(ub.Registration.allow==1).count(): if not g.ubsession.query(ub.Registration).filter(ub.Registration.allow==1).count():
new_domain = ub.Registration(domain="%.%",allow=1) new_domain = ub.Registration(domain="%.%",allow=1)
ub.session.add(new_domain) g.ubsession.add(new_domain)
ub.session.commit() g.ubsession.commit()
return "" return ""
@ -243,7 +243,7 @@ def delete_domain():
@login_required @login_required
@admin_required @admin_required
def list_domain(allow): def list_domain(allow):
answer = ub.session.query(ub.Registration).filter(ub.Registration.allow == allow).all() answer = g.ubsession.query(ub.Registration).filter(ub.Registration.allow == allow).all()
json_dumps = json.dumps([{"domain": r.domain.replace('%', '*').replace('_', '?'), "id": r.id} for r in answer]) json_dumps = json.dumps([{"domain": r.domain.replace('%', '*').replace('_', '?'), "id": r.id} for r in answer])
js = json.dumps(json_dumps.replace('"', "'")).lstrip('"').strip('"') js = json.dumps(json_dumps.replace('"', "'")).lstrip('"').strip('"')
response = make_response(js.replace("'", '"')) response = make_response(js.replace("'", '"'))
@ -269,23 +269,23 @@ def edit_restriction(res_type):
if res_type == 2: # Tags per user if res_type == 2: # Tags per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
elementlist = usr.list_allowed_tags() elementlist = usr.list_allowed_tags()
elementlist[int(element['id'][1:])]=element['Element'] elementlist[int(element['id'][1:])]=element['Element']
usr.allowed_tags = ','.join(elementlist) usr.allowed_tags = ','.join(elementlist)
ub.session.commit() g.ubsession.commit()
if res_type == 3: # CColumn per user if res_type == 3: # CColumn per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
elementlist = usr.list_allowed_column_values() elementlist = usr.list_allowed_column_values()
elementlist[int(element['id'][1:])]=element['Element'] elementlist[int(element['id'][1:])]=element['Element']
usr.allowed_column_value = ','.join(elementlist) usr.allowed_column_value = ','.join(elementlist)
ub.session.commit() g.ubsession.commit()
if element['id'].startswith('d'): if element['id'].startswith('d'):
if res_type == 0: # Tags as template if res_type == 0: # Tags as template
elementlist = config.list_denied_tags() elementlist = config.list_denied_tags()
@ -300,23 +300,23 @@ def edit_restriction(res_type):
if res_type == 2: # Tags per user if res_type == 2: # Tags per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
elementlist = usr.list_denied_tags() elementlist = usr.list_denied_tags()
elementlist[int(element['id'][1:])]=element['Element'] elementlist[int(element['id'][1:])]=element['Element']
usr.denied_tags = ','.join(elementlist) usr.denied_tags = ','.join(elementlist)
ub.session.commit() g.ubsession.commit()
if res_type == 3: # CColumn per user if res_type == 3: # CColumn per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
elementlist = usr.list_denied_column_values() elementlist = usr.list_denied_column_values()
elementlist[int(element['id'][1:])]=element['Element'] elementlist[int(element['id'][1:])]=element['Element']
usr.denied_column_value = ','.join(elementlist) usr.denied_column_value = ','.join(elementlist)
ub.session.commit() g.ubsession.commit()
return "" return ""
def restriction_addition(element, list_func): def restriction_addition(element, list_func):
@ -357,27 +357,27 @@ def add_restriction(res_type):
if res_type == 2: # Tags per user if res_type == 2: # Tags per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
if 'submit_allow' in element: if 'submit_allow' in element:
usr.allowed_tags = restriction_addition(element, usr.list_allowed_tags) usr.allowed_tags = restriction_addition(element, usr.list_allowed_tags)
ub.session.commit() g.ubsession.commit()
elif 'submit_deny' in element: elif 'submit_deny' in element:
usr.denied_tags = restriction_addition(element, usr.list_denied_tags) usr.denied_tags = restriction_addition(element, usr.list_denied_tags)
ub.session.commit() g.ubsession.commit()
if res_type == 3: # CustomC per user if res_type == 3: # CustomC per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
if 'submit_allow' in element: if 'submit_allow' in element:
usr.allowed_column_value = restriction_addition(element, usr.list_allowed_column_values) usr.allowed_column_value = restriction_addition(element, usr.list_allowed_column_values)
ub.session.commit() g.ubsession.commit()
elif 'submit_deny' in element: elif 'submit_deny' in element:
usr.denied_column_value = restriction_addition(element, usr.list_denied_column_values) usr.denied_column_value = restriction_addition(element, usr.list_denied_column_values)
ub.session.commit() g.ubsession.commit()
return "" return ""
@admi.route("/ajax/deleterestriction/<int:res_type>", methods=['POST']) @admi.route("/ajax/deleterestriction/<int:res_type>", methods=['POST'])
@ -402,27 +402,27 @@ def delete_restriction(res_type):
elif res_type == 2: # Tags per user elif res_type == 2: # Tags per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
if element['id'].startswith('a'): if element['id'].startswith('a'):
usr.allowed_tags = restriction_deletion(element, usr.list_allowed_tags) usr.allowed_tags = restriction_deletion(element, usr.list_allowed_tags)
ub.session.commit() g.ubsession.commit()
elif element['id'].startswith('d'): elif element['id'].startswith('d'):
usr.denied_tags = restriction_deletion(element, usr.list_denied_tags) usr.denied_tags = restriction_deletion(element, usr.list_denied_tags)
ub.session.commit() g.ubsession.commit()
elif res_type == 3: # Columns per user elif res_type == 3: # Columns per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: # select current user if admins are editing their own rights if usr_id.isdigit() == True: # select current user if admins are editing their own rights
usr = ub.session.query(ub.User).filter(ub.User.id == int(usr_id)).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == int(usr_id)).first()
else: else:
usr = current_user usr = current_user
if element['id'].startswith('a'): if element['id'].startswith('a'):
usr.allowed_column_value = restriction_deletion(element, usr.list_allowed_column_values) usr.allowed_column_value = restriction_deletion(element, usr.list_allowed_column_values)
ub.session.commit() g.ubsession.commit()
elif element['id'].startswith('d'): elif element['id'].startswith('d'):
usr.denied_column_value = restriction_deletion(element, usr.list_denied_column_values) usr.denied_column_value = restriction_deletion(element, usr.list_denied_column_values)
ub.session.commit() g.ubsession.commit()
return "" return ""
@ -445,7 +445,7 @@ def list_restriction(res_type):
elif res_type == 2: # Tags per user elif res_type == 2: # Tags per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id == usr_id).first() usr = g.ubsession.query(ub.User).filter(ub.User.id == usr_id).first()
else: else:
usr = current_user usr = current_user
restrict = [{'Element': x, 'type':_('Deny'), 'id': 'd'+str(i) } restrict = [{'Element': x, 'type':_('Deny'), 'id': 'd'+str(i) }
@ -456,7 +456,7 @@ def list_restriction(res_type):
elif res_type == 3: # CustomC per user elif res_type == 3: # CustomC per user
usr_id = os.path.split(request.referrer)[-1] usr_id = os.path.split(request.referrer)[-1]
if usr_id.isdigit() == True: if usr_id.isdigit() == True:
usr = ub.session.query(ub.User).filter(ub.User.id==usr_id).first() usr = g.ubsession.query(ub.User).filter(ub.User.id==usr_id).first()
else: else:
usr = current_user usr = current_user
restrict = [{'Element': x, 'type':_('Deny'), 'id': 'd'+str(i) } restrict = [{'Element': x, 'type':_('Deny'), 'id': 'd'+str(i) }
@ -535,7 +535,7 @@ def _configuration_oauth_helper(to_save):
element["active"] = 1 element["active"] = 1
else: else:
element["active"] = 0 element["active"] = 0
ub.session.query(ub.OAuthProvider).filter(ub.OAuthProvider.id == element['id']).update( g.ubsession.query(ub.OAuthProvider).filter(ub.OAuthProvider.id == element['id']).update(
{"oauth_client_id": to_save["config_" + str(element['id']) + "_oauth_client_id"], {"oauth_client_id": to_save["config_" + str(element['id']) + "_oauth_client_id"],
"oauth_client_secret": to_save["config_" + str(element['id']) + "_oauth_client_secret"], "oauth_client_secret": to_save["config_" + str(element['id']) + "_oauth_client_secret"],
"active": element["active"]}) "active": element["active"]})
@ -691,7 +691,7 @@ def _configuration_update_helper():
_config_checkbox(to_save, "config_remote_login") _config_checkbox(to_save, "config_remote_login")
if not config.config_remote_login: if not config.config_remote_login:
ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.token_type==0).delete() g.ubsession.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.token_type==0).delete()
# Goodreads configuration # Goodreads configuration
_config_checkbox(to_save, "config_use_goodreads") _config_checkbox(to_save, "config_use_goodreads")
@ -723,7 +723,7 @@ def _configuration_update_helper():
if unrar_status: if unrar_status:
return _configuration_result(unrar_status, gdriveError) return _configuration_result(unrar_status, gdriveError)
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
_configuration_result(_(u"Settings DB is not Writeable"), gdriveError) _configuration_result(_(u"Settings DB is not Writeable"), gdriveError)
try: try:
@ -791,9 +791,9 @@ def _handle_new_user(to_save, content,languages, translations, kobo_support):
registered_oauth=oauth_check, kobo_support=kobo_support, registered_oauth=oauth_check, kobo_support=kobo_support,
title=_(u"Add new user")) title=_(u"Add new user"))
content.password = generate_password_hash(to_save["password"]) content.password = generate_password_hash(to_save["password"])
existing_user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == to_save["nickname"].lower()) \ existing_user = g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) == to_save["nickname"].lower()) \
.first() .first()
existing_email = ub.session.query(ub.User).filter(ub.User.email == to_save["email"].lower()) \ existing_email = g.ubsession.query(ub.User).filter(ub.User.email == to_save["email"].lower()) \
.first() .first()
if not existing_user and not existing_email: if not existing_user and not existing_email:
content.nickname = to_save["nickname"] content.nickname = to_save["nickname"]
@ -814,31 +814,31 @@ def _handle_new_user(to_save, content,languages, translations, kobo_support):
content.denied_tags = config.config_denied_tags content.denied_tags = config.config_denied_tags
content.allowed_column_value = config.config_allowed_column_value content.allowed_column_value = config.config_allowed_column_value
content.denied_column_value = config.config_denied_column_value content.denied_column_value = config.config_denied_column_value
ub.session.add(content) g.ubsession.add(content)
ub.session.commit() g.ubsession.commit()
flash(_(u"User '%(user)s' created", user=content.nickname), category="success") flash(_(u"User '%(user)s' created", user=content.nickname), category="success")
return redirect(url_for('admin.admin')) return redirect(url_for('admin.admin'))
except IntegrityError: except IntegrityError:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Found an existing account for this e-mail address or nickname."), category="error") flash(_(u"Found an existing account for this e-mail address or nickname."), category="error")
except OperationalError: except OperationalError:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
def _handle_edit_user(to_save, content,languages, translations, kobo_support): def _handle_edit_user(to_save, content,languages, translations, kobo_support):
if "delete" in to_save: if "delete" in to_save:
if ub.session.query(ub.User).filter(ub.User.role.op('&')(constants.ROLE_ADMIN) == constants.ROLE_ADMIN, if g.ubsession.query(ub.User).filter(ub.User.role.op('&')(constants.ROLE_ADMIN) == constants.ROLE_ADMIN,
ub.User.id != content.id).count(): ub.User.id != content.id).count():
ub.session.query(ub.User).filter(ub.User.id == content.id).delete() g.ubsession.query(ub.User).filter(ub.User.id == content.id).delete()
ub.session.commit() g.ubsession.commit()
flash(_(u"User '%(nick)s' deleted", nick=content.nickname), category="success") flash(_(u"User '%(nick)s' deleted", nick=content.nickname), category="success")
return redirect(url_for('admin.admin')) return redirect(url_for('admin.admin'))
else: else:
flash(_(u"No admin user remaining, can't delete user", nick=content.nickname), category="error") flash(_(u"No admin user remaining, can't delete user", nick=content.nickname), category="error")
return redirect(url_for('admin.admin')) return redirect(url_for('admin.admin'))
else: else:
if not ub.session.query(ub.User).filter(ub.User.role.op('&')(constants.ROLE_ADMIN) == constants.ROLE_ADMIN, if not g.ubsession.query(ub.User).filter(ub.User.role.op('&')(constants.ROLE_ADMIN) == constants.ROLE_ADMIN,
ub.User.id != content.id).count() and \ ub.User.id != content.id).count() and \
not 'admin_role' in to_save: not 'admin_role' in to_save:
flash(_(u"No admin user remaining, can't remove admin role", nick=content.nickname), category="error") flash(_(u"No admin user remaining, can't remove admin role", nick=content.nickname), category="error")
@ -872,7 +872,7 @@ def _handle_edit_user(to_save, content,languages, translations, kobo_support):
if "locale" in to_save and to_save["locale"]: if "locale" in to_save and to_save["locale"]:
content.locale = to_save["locale"] content.locale = to_save["locale"]
if to_save["email"] and to_save["email"] != content.email: if to_save["email"] and to_save["email"] != content.email:
existing_email = ub.session.query(ub.User).filter(ub.User.email == to_save["email"].lower()) \ existing_email = g.ubsession.query(ub.User).filter(ub.User.email == to_save["email"].lower()) \
.first() .first()
if not existing_email: if not existing_email:
content.email = to_save["email"] content.email = to_save["email"]
@ -889,7 +889,7 @@ def _handle_edit_user(to_save, content,languages, translations, kobo_support):
title=_(u"Edit User %(nick)s", nick=content.nickname), page="edituser") title=_(u"Edit User %(nick)s", nick=content.nickname), page="edituser")
if "nickname" in to_save and to_save["nickname"] != content.nickname: if "nickname" in to_save and to_save["nickname"] != content.nickname:
# Query User nickname, if not existing, change # Query User nickname, if not existing, change
if not ub.session.query(ub.User).filter(ub.User.nickname == to_save["nickname"]).scalar(): if not g.ubsession.query(ub.User).filter(ub.User.nickname == to_save["nickname"]).scalar():
content.nickname = to_save["nickname"] content.nickname = to_save["nickname"]
else: else:
flash(_(u"This username is already taken"), category="error") flash(_(u"This username is already taken"), category="error")
@ -906,13 +906,13 @@ def _handle_edit_user(to_save, content,languages, translations, kobo_support):
if "kindle_mail" in to_save and to_save["kindle_mail"] != content.kindle_mail: if "kindle_mail" in to_save and to_save["kindle_mail"] != content.kindle_mail:
content.kindle_mail = to_save["kindle_mail"] content.kindle_mail = to_save["kindle_mail"]
try: try:
ub.session.commit() g.ubsession.commit()
flash(_(u"User '%(nick)s' updated", nick=content.nickname), category="success") flash(_(u"User '%(nick)s' updated", nick=content.nickname), category="success")
except IntegrityError: except IntegrityError:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"An unknown error occured."), category="error") flash(_(u"An unknown error occured."), category="error")
except OperationalError: except OperationalError:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
@ -961,7 +961,7 @@ def update_mailsettings():
try: try:
config.save() config.save()
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
return edit_mailsettings() return edit_mailsettings()
@ -985,7 +985,7 @@ def update_mailsettings():
@login_required @login_required
@admin_required @admin_required
def edit_user(user_id): def edit_user(user_id):
content = ub.session.query(ub.User).filter(ub.User.id == int(user_id)).first() # type: ub.User content = g.ubsession.query(ub.User).filter(ub.User.id == int(user_id)).first() # type: ub.User
if not content or (not config.config_anonbrowse and content.nickname == "Guest"): if not content or (not config.config_anonbrowse and content.nickname == "Guest"):
flash(_(u"User not found"), category="error") flash(_(u"User not found"), category="error")
return redirect(url_for('admin.admin')) return redirect(url_for('admin.admin'))

8
cps/config_sql.py
View File

@ -395,7 +395,8 @@ def _migrate_database(session):
_migrate_table(session, _Flask_Settings) _migrate_table(session, _Flask_Settings)
def load_configuration(session): def load_configuration(Session):
session = Session()
_migrate_database(session) _migrate_database(session)
if not session.query(_Settings).count(): if not session.query(_Settings).count():
@ -409,12 +410,15 @@ def load_configuration(session):
session.query(ub.User).filter(ub.User.mature_content != True). \ session.query(ub.User).filter(ub.User.mature_content != True). \
update({"denied_tags": conf.config_mature_content_tags}, synchronize_session=False) update({"denied_tags": conf.config_mature_content_tags}, synchronize_session=False)
session.commit() session.commit()
session.close()
return conf return conf
def get_flask_session_key(session): def get_flask_session_key(Session):
session = Session()
flask_settings = session.query(_Flask_Settings).one_or_none() flask_settings = session.query(_Flask_Settings).one_or_none()
if flask_settings == None: if flask_settings == None:
flask_settings = _Flask_Settings(os.urandom(32)) flask_settings = _Flask_Settings(os.urandom(32))
session.add(flask_settings) session.add(flask_settings)
session.commit() session.commit()
session.close()
return flask_settings.flask_session_key return flask_settings.flask_session_key

5
cps/db.py
View File

@ -32,9 +32,10 @@ from sqlalchemy.orm import relationship, sessionmaker, scoped_session
from sqlalchemy.orm.collections import InstrumentedList from sqlalchemy.orm.collections import InstrumentedList
from sqlalchemy.ext.declarative import declarative_base, DeclarativeMeta from sqlalchemy.ext.declarative import declarative_base, DeclarativeMeta
from sqlalchemy.pool import StaticPool from sqlalchemy.pool import StaticPool
from flask_login import current_user
from sqlalchemy.sql.expression import and_, true, false, text, func, or_ from sqlalchemy.sql.expression import and_, true, false, text, func, or_
from sqlalchemy.ext.associationproxy import association_proxy from sqlalchemy.ext.associationproxy import association_proxy
from flask_login import current_user
from flask import g
from babel import Locale as LC from babel import Locale as LC
from babel.core import UnknownLocaleError from babel.core import UnknownLocaleError
from flask_babel import gettext as _ from flask_babel import gettext as _
@ -564,7 +565,7 @@ class CalibreDB():
def common_filters(self, allow_show_archived=False): def common_filters(self, allow_show_archived=False):
if not allow_show_archived: if not allow_show_archived:
archived_books = ( archived_books = (
ub.session.query(ub.ArchivedBook) g.ubsession.query(ub.ArchivedBook)
.filter(ub.ArchivedBook.user_id == int(current_user.id)) .filter(ub.ArchivedBook.user_id == int(current_user.id))
.filter(ub.ArchivedBook.is_archived == True) .filter(ub.ArchivedBook.is_archived == True)
.all() .all()

8
cps/editbooks.py
View File

@ -27,7 +27,7 @@ import json
from shutil import copyfile from shutil import copyfile
from uuid import uuid4 from uuid import uuid4
from flask import Blueprint, request, flash, redirect, url_for, abort, Markup, Response from flask import Blueprint, request, flash, redirect, url_for, abort, Markup, Response, g
from flask_babel import gettext as _ from flask_babel import gettext as _
from flask_login import current_user, login_required from flask_login import current_user, login_required
from sqlalchemy.exc import OperationalError from sqlalchemy.exc import OperationalError
@ -212,10 +212,10 @@ def delete_book(book_id, book_format, jsonResponse):
flash(error, category="warning") flash(error, category="warning")
if not book_format: if not book_format:
# delete book from Shelfs, Downloads, Read list # delete book from Shelfs, Downloads, Read list
ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == book_id).delete() g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.book_id == book_id).delete()
ub.session.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id).delete() g.ubsession.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id).delete()
ub.delete_download(book_id) ub.delete_download(book_id)
ub.session.commit() g.ubsession.commit()
# check if only this book links to: # check if only this book links to:
# author, language, series, tags, custom columns # author, language, series, tags, custom columns

15
cps/helper.py
View File

@ -24,10 +24,7 @@ import io
import mimetypes import mimetypes
import re import re
import shutil import shutil
import glob
import time import time
import zipfile
import json
import unicodedata import unicodedata
from datetime import datetime, timedelta from datetime import datetime, timedelta
from tempfile import gettempdir from tempfile import gettempdir
@ -35,7 +32,7 @@ from tempfile import gettempdir
import requests import requests
from babel.dates import format_datetime from babel.dates import format_datetime
from babel.units import format_unit from babel.units import format_unit
from flask import send_from_directory, make_response, redirect, abort, url_for, send_file from flask import send_from_directory, make_response, redirect, abort, url_for, g
from flask_babel import gettext as _ from flask_babel import gettext as _
from flask_login import current_user from flask_login import current_user
from sqlalchemy.sql.expression import true, false, and_, text from sqlalchemy.sql.expression import true, false, and_, text
@ -485,7 +482,7 @@ def delete_book_gdrive(book, book_format):
def reset_password(user_id): def reset_password(user_id):
existing_user = ub.session.query(ub.User).filter(ub.User.id == user_id).first() existing_user = g.ubsession.query(ub.User).filter(ub.User.id == user_id).first()
if not existing_user: if not existing_user:
return 0, None return 0, None
if not config.get_mail_server_configured(): if not config.get_mail_server_configured():
@ -493,11 +490,11 @@ def reset_password(user_id):
try: try:
password = generate_random_password() password = generate_random_password()
existing_user.password = generate_password_hash(password) existing_user.password = generate_password_hash(password)
ub.session.commit() g.ubsession.commit()
send_registration_mail(existing_user.email, existing_user.nickname, password, True) send_registration_mail(existing_user.email, existing_user.nickname, password, True)
return 1, existing_user.nickname return 1, existing_user.nickname
except Exception: except Exception:
ub.session.rollback() g.ubsession.rollback()
return 0, None return 0, None
@ -779,11 +776,11 @@ def tags_filters():
def check_valid_domain(domain_text): def check_valid_domain(domain_text):
# domain_text = domain_text.split('@', 1)[-1].lower() # domain_text = domain_text.split('@', 1)[-1].lower()
sql = "SELECT * FROM registration WHERE (:domain LIKE domain and allow = 1);" sql = "SELECT * FROM registration WHERE (:domain LIKE domain and allow = 1);"
result = ub.session.query(ub.Registration).from_statement(text(sql)).params(domain=domain_text).all() result = g.ubsession.query(ub.Registration).from_statement(text(sql)).params(domain=domain_text).all()
if not len(result): if not len(result):
return False return False
sql = "SELECT * FROM registration WHERE (:domain LIKE domain and allow = 0);" sql = "SELECT * FROM registration WHERE (:domain LIKE domain and allow = 0);"
result = ub.session.query(ub.Registration).from_statement(text(sql)).params(domain=domain_text).all() result = g.ubsession.query(ub.Registration).from_statement(text(sql)).params(domain=domain_text).all()
return not len(result) return not len(result)

51
cps/kobo.py
View File

@ -37,7 +37,8 @@ from flask import (
current_app, current_app,
url_for, url_for,
redirect, redirect,
abort abort,
g
) )
from flask_login import current_user from flask_login import current_user
from werkzeug.datastructures import Headers from werkzeug.datastructures import Headers
@ -210,7 +211,7 @@ def HandleSyncRequest():
# generate reading state data # generate reading state data
changed_reading_states = ( changed_reading_states = (
ub.session.query(ub.KoboReadingState) g.ubsession.query(ub.KoboReadingState)
.filter(and_(func.datetime(ub.KoboReadingState.last_modified) > sync_token.reading_state_last_modified, .filter(and_(func.datetime(ub.KoboReadingState.last_modified) > sync_token.reading_state_last_modified,
ub.KoboReadingState.user_id == current_user.id, ub.KoboReadingState.user_id == current_user.id,
ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements)))) ub.KoboReadingState.book_id.notin_(reading_states_in_new_entitlements))))
@ -439,19 +440,19 @@ def HandleTagCreate():
log.debug("Received malformed v1/library/tags request.") log.debug("Received malformed v1/library/tags request.")
abort(400, description="Malformed tags POST request. Data has empty 'Name', missing 'Name' or 'Items' field") abort(400, description="Malformed tags POST request. Data has empty 'Name', missing 'Name' or 'Items' field")
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.name == name, ub.Shelf.user_id == shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.name == name, ub.Shelf.user_id ==
current_user.id).one_or_none() current_user.id).one_or_none()
if shelf and not shelf_lib.check_shelf_edit_permissions(shelf): if shelf and not shelf_lib.check_shelf_edit_permissions(shelf):
abort(401, description="User is unauthaurized to create shelf.") abort(401, description="User is unauthaurized to create shelf.")
if not shelf: if not shelf:
shelf = ub.Shelf(user_id=current_user.id, name=name, uuid=str(uuid.uuid4())) shelf = ub.Shelf(user_id=current_user.id, name=name, uuid=str(uuid.uuid4()))
ub.session.add(shelf) g.ubsession.add(shelf)
items_unknown_to_calibre = add_items_to_shelf(items, shelf) items_unknown_to_calibre = add_items_to_shelf(items, shelf)
if items_unknown_to_calibre: if items_unknown_to_calibre:
log.debug("Received request to add unknown books to a collection. Silently ignoring items.") log.debug("Received request to add unknown books to a collection. Silently ignoring items.")
ub.session.commit() g.ubsession.commit()
return make_response(jsonify(str(shelf.uuid)), 201) return make_response(jsonify(str(shelf.uuid)), 201)
@ -459,7 +460,7 @@ def HandleTagCreate():
@kobo.route("/v1/library/tags/<tag_id>", methods=["DELETE", "PUT"]) @kobo.route("/v1/library/tags/<tag_id>", methods=["DELETE", "PUT"])
@requires_kobo_auth @requires_kobo_auth
def HandleTagUpdate(tag_id): def HandleTagUpdate(tag_id):
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id,
ub.Shelf.user_id == current_user.id).one_or_none() ub.Shelf.user_id == current_user.id).one_or_none()
if not shelf: if not shelf:
log.debug("Received Kobo tag update request on a collection unknown to CalibreWeb") log.debug("Received Kobo tag update request on a collection unknown to CalibreWeb")
@ -483,8 +484,8 @@ def HandleTagUpdate(tag_id):
abort(400, description="Malformed tags POST request. Data is missing 'Name' field") abort(400, description="Malformed tags POST request. Data is missing 'Name' field")
shelf.name = name shelf.name = name
ub.session.merge(shelf) g.ubsession.merge(shelf)
ub.session.commit() g.ubsession.commit()
return make_response(' ', 200) return make_response(' ', 200)
@ -522,7 +523,7 @@ def HandleTagAddItem(tag_id):
log.debug("Received malformed v1/library/tags/<tag_id>/items/delete request.") log.debug("Received malformed v1/library/tags/<tag_id>/items/delete request.")
abort(400, description="Malformed tags POST request. Data is missing 'Items' field") abort(400, description="Malformed tags POST request. Data is missing 'Items' field")
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id,
ub.Shelf.user_id == current_user.id).one_or_none() ub.Shelf.user_id == current_user.id).one_or_none()
if not shelf: if not shelf:
log.debug("Received Kobo request on a collection unknown to CalibreWeb") log.debug("Received Kobo request on a collection unknown to CalibreWeb")
@ -535,8 +536,8 @@ def HandleTagAddItem(tag_id):
if items_unknown_to_calibre: if items_unknown_to_calibre:
log.debug("Received request to add an unknown book to a collection. Silently ignoring item.") log.debug("Received request to add an unknown book to a collection. Silently ignoring item.")
ub.session.merge(shelf) g.ubsession.merge(shelf)
ub.session.commit() g.ubsession.commit()
return make_response('', 201) return make_response('', 201)
@ -552,7 +553,7 @@ def HandleTagRemoveItem(tag_id):
log.debug("Received malformed v1/library/tags/<tag_id>/items/delete request.") log.debug("Received malformed v1/library/tags/<tag_id>/items/delete request.")
abort(400, description="Malformed tags POST request. Data is missing 'Items' field") abort(400, description="Malformed tags POST request. Data is missing 'Items' field")
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id, shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.uuid == tag_id,
ub.Shelf.user_id == current_user.id).one_or_none() ub.Shelf.user_id == current_user.id).one_or_none()
if not shelf: if not shelf:
log.debug( log.debug(
@ -577,7 +578,7 @@ def HandleTagRemoveItem(tag_id):
shelf.books.filter(ub.BookShelf.book_id == book.id).delete() shelf.books.filter(ub.BookShelf.book_id == book.id).delete()
except KeyError: except KeyError:
items_unknown_to_calibre.append(item) items_unknown_to_calibre.append(item)
ub.session.commit() g.ubsession.commit()
if items_unknown_to_calibre: if items_unknown_to_calibre:
log.debug("Received request to remove an unknown book to a collecition. Silently ignoring item.") log.debug("Received request to remove an unknown book to a collecition. Silently ignoring item.")
@ -590,7 +591,7 @@ def HandleTagRemoveItem(tag_id):
def sync_shelves(sync_token, sync_results): def sync_shelves(sync_token, sync_results):
new_tags_last_modified = sync_token.tags_last_modified 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, for shelf in g.ubsession.query(ub.ShelfArchive).filter(func.datetime(ub.ShelfArchive.last_modified) > sync_token.tags_last_modified,
ub.ShelfArchive.user_id == current_user.id): ub.ShelfArchive.user_id == current_user.id):
new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified) new_tags_last_modified = max(shelf.last_modified, new_tags_last_modified)
@ -603,7 +604,7 @@ 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, for shelf in g.ubsession.query(ub.Shelf).filter(func.datetime(ub.Shelf.last_modified) > sync_token.tags_last_modified,
ub.Shelf.user_id == current_user.id): ub.Shelf.user_id == current_user.id):
if not shelf_lib.check_shelf_view_permissions(shelf): if not shelf_lib.check_shelf_view_permissions(shelf):
continue continue
@ -623,7 +624,7 @@ def sync_shelves(sync_token, sync_results):
"ChangedTag": tag "ChangedTag": tag
}) })
sync_token.tags_last_modified = new_tags_last_modified sync_token.tags_last_modified = new_tags_last_modified
ub.session.commit() g.ubsession.commit()
# Creates a Kobo "Tag" object from a ub.Shelf object # Creates a Kobo "Tag" object from a ub.Shelf object
@ -700,11 +701,11 @@ def HandleStateRequest(book_uuid):
update_results_response["StatusInfoResult"] = {"Result": "Success"} update_results_response["StatusInfoResult"] = {"Result": "Success"}
except (KeyError, TypeError, ValueError, StatementError): except (KeyError, TypeError, ValueError, StatementError):
log.debug("Received malformed v1/library/<book_uuid>/state request.") log.debug("Received malformed v1/library/<book_uuid>/state request.")
ub.session.rollback() g.ubsession.rollback()
abort(400, description="Malformed request data is missing 'ReadingStates' key") abort(400, description="Malformed request data is missing 'ReadingStates' key")
ub.session.merge(kobo_reading_state) g.ubsession.merge(kobo_reading_state)
ub.session.commit() g.ubsession.commit()
return jsonify({ return jsonify({
"RequestResult": "Success", "RequestResult": "Success",
"UpdateResults": [update_results_response], "UpdateResults": [update_results_response],
@ -732,7 +733,7 @@ def get_ub_read_status(kobo_read_status):
def get_or_create_reading_state(book_id): def get_or_create_reading_state(book_id):
book_read = ub.session.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id, book_read = g.ubsession.query(ub.ReadBook).filter(ub.ReadBook.book_id == book_id,
ub.ReadBook.user_id == current_user.id).one_or_none() ub.ReadBook.user_id == current_user.id).one_or_none()
if not book_read: if not book_read:
book_read = ub.ReadBook(user_id=current_user.id, book_id=book_id) book_read = ub.ReadBook(user_id=current_user.id, book_id=book_id)
@ -741,8 +742,8 @@ def get_or_create_reading_state(book_id):
kobo_reading_state.current_bookmark = ub.KoboBookmark() kobo_reading_state.current_bookmark = ub.KoboBookmark()
kobo_reading_state.statistics = ub.KoboStatistics() kobo_reading_state.statistics = ub.KoboStatistics()
book_read.kobo_reading_state = kobo_reading_state book_read.kobo_reading_state = kobo_reading_state
ub.session.add(book_read) g.ubsession.add(book_read)
ub.session.commit() g.ubsession.commit()
return book_read.kobo_reading_state return book_read.kobo_reading_state
@ -835,7 +836,7 @@ def HandleBookDeletionRequest(book_uuid):
book_id = book.id book_id = book.id
archived_book = ( archived_book = (
ub.session.query(ub.ArchivedBook) g.ubsession.query(ub.ArchivedBook)
.filter(ub.ArchivedBook.book_id == book_id) .filter(ub.ArchivedBook.book_id == book_id)
.first() .first()
) )
@ -844,8 +845,8 @@ def HandleBookDeletionRequest(book_uuid):
archived_book.is_archived = True archived_book.is_archived = True
archived_book.last_modified = datetime.datetime.utcnow() archived_book.last_modified = datetime.datetime.utcnow()
ub.session.merge(archived_book) g.ubsession.merge(archived_book)
ub.session.commit() g.ubsession.commit()
return ("", 204) return ("", 204)

12
cps/kobo_auth.py
View File

@ -102,7 +102,7 @@ def requires_kobo_auth(f):
auth_token = get_auth_token() auth_token = get_auth_token()
if auth_token is not None: if auth_token is not None:
user = ( user = (
ub.session.query(ub.User) g.ubsession.query(ub.User)
.join(ub.RemoteAuthToken) .join(ub.RemoteAuthToken)
.filter(ub.RemoteAuthToken.auth_token == auth_token).filter(ub.RemoteAuthToken.token_type==1) .filter(ub.RemoteAuthToken.auth_token == auth_token).filter(ub.RemoteAuthToken.token_type==1)
.first() .first()
@ -135,7 +135,7 @@ def generate_auth_token(user_id):
) )
else: else:
# Invalidate any prevously generated Kobo Auth token for this user. # Invalidate any prevously generated Kobo Auth token for this user.
auth_token = ub.session.query(ub.RemoteAuthToken).filter( auth_token = g.ubsession.query(ub.RemoteAuthToken).filter(
ub.RemoteAuthToken.user_id == user_id ub.RemoteAuthToken.user_id == user_id
).filter(ub.RemoteAuthToken.token_type==1).first() ).filter(ub.RemoteAuthToken.token_type==1).first()
@ -146,8 +146,8 @@ def generate_auth_token(user_id):
auth_token.auth_token = (hexlify(urandom(16))).decode("utf-8") auth_token.auth_token = (hexlify(urandom(16))).decode("utf-8")
auth_token.token_type = 1 auth_token.token_type = 1
ub.session.add(auth_token) g.ubsession.add(auth_token)
ub.session.commit() g.ubsession.commit()
return render_title_template( return render_title_template(
"generate_kobo_auth_url.html", "generate_kobo_auth_url.html",
title=_(u"Kobo Setup"), title=_(u"Kobo Setup"),
@ -162,7 +162,7 @@ def generate_auth_token(user_id):
@login_required @login_required
def delete_auth_token(user_id): def delete_auth_token(user_id):
# Invalidate any prevously generated Kobo Auth token for this user. # Invalidate any prevously generated Kobo Auth token for this user.
ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.user_id == user_id)\ g.ubsession.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.user_id == user_id)\
.filter(ub.RemoteAuthToken.token_type==1).delete() .filter(ub.RemoteAuthToken.token_type==1).delete()
ub.session.commit() g.ubsession.commit()
return "" return ""

48
cps/oauth_bb.py
View File

@ -24,7 +24,7 @@ from __future__ import division, print_function, unicode_literals
import json import json
from functools import wraps from functools import wraps
from flask import session, request, make_response, abort from flask import session, request, make_response, abort, g
from flask import Blueprint, flash, redirect, url_for from flask import Blueprint, flash, redirect, url_for
from flask_babel import gettext as _ from flask_babel import gettext as _
from flask_dance.consumer import oauth_authorized, oauth_error from flask_dance.consumer import oauth_authorized, oauth_error
@ -74,7 +74,7 @@ def register_user_with_oauth(user=None):
else: else:
for oauth_key in all_oauth.keys(): for oauth_key in all_oauth.keys():
# Find this OAuth token in the database, or create it # Find this OAuth token in the database, or create it
query = ub.session.query(ub.OAuth).filter_by( query = g.ubsession.query(ub.OAuth).filter_by(
provider=oauth_key, provider=oauth_key,
provider_user_id=session[str(oauth_key) + "_oauth_user_id"], provider_user_id=session[str(oauth_key) + "_oauth_user_id"],
) )
@ -85,10 +85,10 @@ def register_user_with_oauth(user=None):
# no found, return error # no found, return error
return return
try: try:
ub.session.commit() g.ubsession.commit()
except Exception as e: except Exception as e:
log.exception(e) log.exception(e)
ub.session.rollback() g.ubsession.rollback()
def logout_oauth_user(): def logout_oauth_user():
@ -99,19 +99,19 @@ def logout_oauth_user():
if ub.oauth_support: if ub.oauth_support:
oauthblueprints = [] oauthblueprints = []
if not ub.session.query(ub.OAuthProvider).count(): if not g.ubsession.query(ub.OAuthProvider).count():
oauthProvider = ub.OAuthProvider() oauthProvider = ub.OAuthProvider()
oauthProvider.provider_name = "github" oauthProvider.provider_name = "github"
oauthProvider.active = False oauthProvider.active = False
ub.session.add(oauthProvider) g.ubsession.add(oauthProvider)
ub.session.commit() g.ubsession.commit()
oauthProvider = ub.OAuthProvider() oauthProvider = ub.OAuthProvider()
oauthProvider.provider_name = "google" oauthProvider.provider_name = "google"
oauthProvider.active = False oauthProvider.active = False
ub.session.add(oauthProvider) g.ubsession.add(oauthProvider)
ub.session.commit() g.ubsession.commit()
oauth_ids = ub.session.query(ub.OAuthProvider).all() oauth_ids = g.ubsession.query(ub.OAuthProvider).all()
ele1 = dict(provider_name='github', ele1 = dict(provider_name='github',
id=oauth_ids[0].id, id=oauth_ids[0].id,
active=oauth_ids[0].active, active=oauth_ids[0].active,
@ -141,7 +141,7 @@ if ub.oauth_support:
scope=element['scope'] scope=element['scope']
) )
element['blueprint'] = blueprint element['blueprint'] = blueprint
element['blueprint'].backend = OAuthBackend(ub.OAuth, ub.session, str(element['id']), element['blueprint'].backend = OAuthBackend(ub.OAuth, g.ubsession, str(element['id']),
user=current_user, user_required=True) user=current_user, user_required=True)
app.register_blueprint(blueprint, url_prefix="/login") app.register_blueprint(blueprint, url_prefix="/login")
if element['active']: if element['active']:
@ -185,7 +185,7 @@ if ub.oauth_support:
session[provider_id + "_oauth_token"] = token session[provider_id + "_oauth_token"] = token
# Find this OAuth token in the database, or create it # Find this OAuth token in the database, or create it
query = ub.session.query(ub.OAuth).filter_by( query = g.ubsession.query(ub.OAuth).filter_by(
provider=provider_id, provider=provider_id,
provider_user_id=provider_user_id, provider_user_id=provider_user_id,
) )
@ -200,11 +200,11 @@ if ub.oauth_support:
token=token, token=token,
) )
try: try:
ub.session.add(oauth_entry) g.ubsession.add(oauth_entry)
ub.session.commit() g.ubsession.commit()
except Exception as e: except Exception as e:
log.exception(e) log.exception(e)
ub.session.rollback() g.ubsession.rollback()
# Disable Flask-Dance's default behavior for saving the OAuth token # Disable Flask-Dance's default behavior for saving the OAuth token
# Value differrs depending on flask-dance version # Value differrs depending on flask-dance version
@ -212,7 +212,7 @@ if ub.oauth_support:
def bind_oauth_or_register(provider_id, provider_user_id, redirect_url, provider_name): def bind_oauth_or_register(provider_id, provider_user_id, redirect_url, provider_name):
query = ub.session.query(ub.OAuth).filter_by( query = g.ubsession.query(ub.OAuth).filter_by(
provider=provider_id, provider=provider_id,
provider_user_id=provider_user_id, provider_user_id=provider_user_id,
) )
@ -230,13 +230,13 @@ if ub.oauth_support:
if current_user and current_user.is_authenticated: if current_user and current_user.is_authenticated:
oauth_entry.user = current_user oauth_entry.user = current_user
try: try:
ub.session.add(oauth_entry) g.ubsession.add(oauth_entry)
ub.session.commit() g.ubsession.commit()
flash(_(u"Link to %(oauth)s Succeeded", oauth=provider_name), category="success") flash(_(u"Link to %(oauth)s Succeeded", oauth=provider_name), category="success")
return redirect(url_for('web.profile')) return redirect(url_for('web.profile'))
except Exception as e: except Exception as e:
log.exception(e) log.exception(e)
ub.session.rollback() g.ubsession.rollback()
else: else:
flash(_(u"Login failed, No User Linked With OAuth Account"), category="error") flash(_(u"Login failed, No User Linked With OAuth Account"), category="error")
log.info('Login failed, No User Linked With OAuth Account') log.info('Login failed, No User Linked With OAuth Account')
@ -253,7 +253,7 @@ if ub.oauth_support:
def get_oauth_status(): def get_oauth_status():
status = [] status = []
query = ub.session.query(ub.OAuth).filter_by( query = g.ubsession.query(ub.OAuth).filter_by(
user_id=current_user.id, user_id=current_user.id,
) )
try: try:
@ -268,7 +268,7 @@ if ub.oauth_support:
def unlink_oauth(provider): def unlink_oauth(provider):
if request.host_url + 'me' != request.referrer: if request.host_url + 'me' != request.referrer:
pass pass
query = ub.session.query(ub.OAuth).filter_by( query = g.ubsession.query(ub.OAuth).filter_by(
provider=provider, provider=provider,
user_id=current_user.id, user_id=current_user.id,
) )
@ -277,13 +277,13 @@ if ub.oauth_support:
if current_user and current_user.is_authenticated: if current_user and current_user.is_authenticated:
oauth_entry.user = current_user oauth_entry.user = current_user
try: try:
ub.session.delete(oauth_entry) g.ubsession.delete(oauth_entry)
ub.session.commit() g.ubsession.commit()
logout_oauth_user() logout_oauth_user()
flash(_(u"Unlink to %(oauth)s Succeeded", oauth=oauth_check[provider]), category="success") flash(_(u"Unlink to %(oauth)s Succeeded", oauth=oauth_check[provider]), category="success")
except Exception as e: except Exception as e:
log.exception(e) log.exception(e)
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Unlink to %(oauth)s Failed", oauth=oauth_check[provider]), category="error") flash(_(u"Unlink to %(oauth)s Failed", oauth=oauth_check[provider]), category="error")
except NoResultFound: except NoResultFound:
log.warning("oauth %s for user %d not found", provider, current_user.id) log.warning("oauth %s for user %d not found", provider, current_user.id)

12
cps/opds.py
View File

@ -33,7 +33,7 @@ from werkzeug.security import check_password_hash
from . import constants, logger, config, db, calibre_db, ub, services, get_locale, isoLanguages from . import constants, logger, config, db, calibre_db, ub, services, get_locale, isoLanguages
from .helper import get_download_link, get_book_cover from .helper import get_download_link, get_book_cover
from .pagination import Pagination from .pagination import Pagination
from .web import render_read_books, download_required, load_user_from_request from .web import render_read_books, load_user_from_request
from flask_babel import gettext as _ from flask_babel import gettext as _
from babel import Locale as LC from babel import Locale as LC
from babel.core import UnknownLocaleError from babel.core import UnknownLocaleError
@ -128,7 +128,7 @@ def feed_best_rated():
@requires_basic_auth_if_no_ano @requires_basic_auth_if_no_ano
def feed_hot(): def feed_hot():
off = request.args.get("offset") or 0 off = request.args.get("offset") or 0
all_books = ub.session.query(ub.Downloads, func.count(ub.Downloads.book_id)).order_by( all_books = g.ubsession.query(ub.Downloads, func.count(ub.Downloads.book_id)).order_by(
func.count(ub.Downloads.book_id).desc()).group_by(ub.Downloads.book_id) func.count(ub.Downloads.book_id).desc()).group_by(ub.Downloads.book_id)
hot_books = all_books.offset(off).limit(config.config_books_per_page) hot_books = all_books.offset(off).limit(config.config_books_per_page)
entries = list() entries = list()
@ -361,17 +361,17 @@ def feed_shelfindex():
def feed_shelf(book_id): def feed_shelf(book_id):
off = request.args.get("offset") or 0 off = request.args.get("offset") or 0
if current_user.is_anonymous: if current_user.is_anonymous:
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.is_public == 1, shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.is_public == 1,
ub.Shelf.id == book_id).first() ub.Shelf.id == book_id).first()
else: else:
shelf = ub.session.query(ub.Shelf).filter(or_(and_(ub.Shelf.user_id == int(current_user.id), shelf = g.ubsession.query(ub.Shelf).filter(or_(and_(ub.Shelf.user_id == int(current_user.id),
ub.Shelf.id == book_id), ub.Shelf.id == book_id),
and_(ub.Shelf.is_public == 1, and_(ub.Shelf.is_public == 1,
ub.Shelf.id == book_id))).first() ub.Shelf.id == book_id))).first()
result = list() result = list()
# user is allowed to access shelf # user is allowed to access shelf
if shelf: if shelf:
books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == book_id).order_by( books_in_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == book_id).order_by(
ub.BookShelf.order.asc()).all() ub.BookShelf.order.asc()).all()
for book in books_in_shelf: for book in books_in_shelf:
cur_book = calibre_db.get_book(book.book_id) cur_book = calibre_db.get_book(book.book_id)
@ -427,7 +427,7 @@ def check_auth(username, password):
username = username.encode('windows-1252') username = username.encode('windows-1252')
except UnicodeEncodeError: except UnicodeEncodeError:
username = username.encode('utf-8') username = username.encode('utf-8')
user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == user = g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) ==
username.decode('utf-8').lower()).first() username.decode('utf-8').lower()).first()
return bool(user and check_password_hash(str(user.password), password)) return bool(user and check_password_hash(str(user.password), password))

92
cps/shelf.py
View File

@ -23,7 +23,7 @@
from __future__ import division, print_function, unicode_literals from __future__ import division, print_function, unicode_literals
from datetime import datetime from datetime import datetime
from flask import Blueprint, request, flash, redirect, url_for from flask import Blueprint, request, flash, redirect, url_for, g
from flask_babel import gettext as _ from flask_babel import gettext as _
from flask_login import login_required, current_user from flask_login import login_required, current_user
from sqlalchemy.sql.expression import func from sqlalchemy.sql.expression import func
@ -60,7 +60,7 @@ def check_shelf_view_permissions(cur_shelf):
@login_required @login_required
def add_to_shelf(shelf_id, book_id): def add_to_shelf(shelf_id, book_id):
xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest' xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest'
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
if shelf is None: if shelf is None:
log.error("Invalid shelf specified: %s", shelf_id) log.error("Invalid shelf specified: %s", shelf_id)
if not xhr: if not xhr:
@ -75,7 +75,7 @@ def add_to_shelf(shelf_id, book_id):
return redirect(url_for('web.index')) 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 the shelf: %s" % shelf.name, 403
book_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id, book_in_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id,
ub.BookShelf.book_id == book_id).first() ub.BookShelf.book_id == book_id).first()
if book_in_shelf: if book_in_shelf:
log.error("Book %s is already part of %s", book_id, shelf) log.error("Book %s is already part of %s", book_id, shelf)
@ -84,7 +84,7 @@ def add_to_shelf(shelf_id, book_id):
return redirect(url_for('web.index')) return redirect(url_for('web.index'))
return "Book is already part of the shelf: %s" % shelf.name, 400 return "Book is already part of the shelf: %s" % shelf.name, 400
maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first() maxOrder = g.ubsession.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()
if maxOrder[0] is None: if maxOrder[0] is None:
maxOrder = 0 maxOrder = 0
else: else:
@ -93,10 +93,10 @@ def add_to_shelf(shelf_id, book_id):
shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1)) shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1))
shelf.last_modified = datetime.utcnow() shelf.last_modified = datetime.utcnow()
try: try:
ub.session.merge(shelf) g.ubsession.merge(shelf)
ub.session.commit() g.ubsession.commit()
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
if "HTTP_REFERER" in request.environ: if "HTTP_REFERER" in request.environ:
return redirect(request.environ["HTTP_REFERER"]) return redirect(request.environ["HTTP_REFERER"])
@ -114,7 +114,7 @@ def add_to_shelf(shelf_id, book_id):
@shelf.route("/shelf/massadd/<int:shelf_id>") @shelf.route("/shelf/massadd/<int:shelf_id>")
@login_required @login_required
def search_to_shelf(shelf_id): def search_to_shelf(shelf_id):
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
if shelf is None: if shelf is None:
log.error("Invalid shelf specified: %s", shelf_id) log.error("Invalid shelf specified: %s", shelf_id)
flash(_(u"Invalid shelf specified"), category="error") flash(_(u"Invalid shelf specified"), category="error")
@ -126,7 +126,7 @@ def search_to_shelf(shelf_id):
if current_user.id in ub.searched_ids and ub.searched_ids[current_user.id]: if current_user.id in ub.searched_ids and ub.searched_ids[current_user.id]:
books_for_shelf = list() books_for_shelf = list()
books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).all() books_in_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).all()
if books_in_shelf: if books_in_shelf:
book_ids = list() book_ids = list()
for book_id in books_in_shelf: for book_id in books_in_shelf:
@ -142,7 +142,7 @@ def search_to_shelf(shelf_id):
flash(_(u"Books are already part of the shelf: %(name)s", name=shelf.name), category="error") flash(_(u"Books are already part of the shelf: %(name)s", name=shelf.name), category="error")
return redirect(url_for('web.index')) return redirect(url_for('web.index'))
maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first() maxOrder = g.ubsession.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()
if maxOrder[0] is None: if maxOrder[0] is None:
maxOrder = 0 maxOrder = 0
else: else:
@ -153,11 +153,11 @@ def search_to_shelf(shelf_id):
shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book, order=maxOrder)) shelf.books.append(ub.BookShelf(shelf=shelf.id, book_id=book, order=maxOrder))
shelf.last_modified = datetime.utcnow() shelf.last_modified = datetime.utcnow()
try: try:
ub.session.merge(shelf) g.ubsession.merge(shelf)
ub.session.commit() g.ubsession.commit()
flash(_(u"Books have been added to shelf: %(sname)s", sname=shelf.name), category="success") flash(_(u"Books have been added to shelf: %(sname)s", sname=shelf.name), category="success")
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
else: else:
flash(_(u"Could not add books to shelf: %(sname)s", sname=shelf.name), category="error") flash(_(u"Could not add books to shelf: %(sname)s", sname=shelf.name), category="error")
@ -168,7 +168,7 @@ def search_to_shelf(shelf_id):
@login_required @login_required
def remove_from_shelf(shelf_id, book_id): def remove_from_shelf(shelf_id, book_id):
xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest' xhr = request.headers.get('X-Requested-With') == 'XMLHttpRequest'
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
if shelf is None: if shelf is None:
log.error("Invalid shelf specified: %s", shelf_id) log.error("Invalid shelf specified: %s", shelf_id)
if not xhr: if not xhr:
@ -184,7 +184,7 @@ def remove_from_shelf(shelf_id, book_id):
# false 0 x 0 # false 0 x 0
if check_shelf_edit_permissions(shelf): if check_shelf_edit_permissions(shelf):
book_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id, book_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id,
ub.BookShelf.book_id == book_id).first() ub.BookShelf.book_id == book_id).first()
if book_shelf is None: if book_shelf is None:
@ -194,11 +194,11 @@ def remove_from_shelf(shelf_id, book_id):
return "Book already removed from shelf", 410 return "Book already removed from shelf", 410
try: try:
ub.session.delete(book_shelf) g.ubsession.delete(book_shelf)
shelf.last_modified = datetime.utcnow() shelf.last_modified = datetime.utcnow()
ub.session.commit() g.ubsession.commit()
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
if "HTTP_REFERER" in request.environ: if "HTTP_REFERER" in request.environ:
return redirect(request.environ["HTTP_REFERER"]) return redirect(request.environ["HTTP_REFERER"])
@ -232,7 +232,7 @@ def create_shelf():
is_shelf_name_unique = False is_shelf_name_unique = False
if shelf.is_public == 1: if shelf.is_public == 1:
is_shelf_name_unique = ub.session.query(ub.Shelf) \ is_shelf_name_unique = g.ubsession.query(ub.Shelf) \
.filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \ .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \
.first() is None .first() is None
@ -240,7 +240,7 @@ def create_shelf():
flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]), flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]),
category="error") category="error")
else: else:
is_shelf_name_unique = ub.session.query(ub.Shelf) \ is_shelf_name_unique = g.ubsession.query(ub.Shelf) \
.filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) & .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) &
(ub.Shelf.user_id == int(current_user.id)))\ (ub.Shelf.user_id == int(current_user.id)))\
.first() is None .first() is None
@ -251,15 +251,15 @@ def create_shelf():
if is_shelf_name_unique: if is_shelf_name_unique:
try: try:
ub.session.add(shelf) g.ubsession.add(shelf)
ub.session.commit() g.ubsession.commit()
flash(_(u"Shelf %(title)s created", title=to_save["title"]), category="success") flash(_(u"Shelf %(title)s created", title=to_save["title"]), category="success")
return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id)) return redirect(url_for('shelf.show_shelf', shelf_id=shelf.id))
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
except Exception: except Exception:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"There was an error"), category="error") flash(_(u"There was an error"), category="error")
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Create a Shelf"), page="shelfcreate") return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Create a Shelf"), page="shelfcreate")
else: else:
@ -269,13 +269,13 @@ def create_shelf():
@shelf.route("/shelf/edit/<int:shelf_id>", methods=["GET", "POST"]) @shelf.route("/shelf/edit/<int:shelf_id>", methods=["GET", "POST"])
@login_required @login_required
def edit_shelf(shelf_id): def edit_shelf(shelf_id):
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
if request.method == "POST": if request.method == "POST":
to_save = request.form.to_dict() to_save = request.form.to_dict()
is_shelf_name_unique = False is_shelf_name_unique = False
if shelf.is_public == 1: if shelf.is_public == 1:
is_shelf_name_unique = ub.session.query(ub.Shelf) \ is_shelf_name_unique = g.ubsession.query(ub.Shelf) \
.filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \ .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 1)) \
.filter(ub.Shelf.id != shelf_id) \ .filter(ub.Shelf.id != shelf_id) \
.first() is None .first() is None
@ -284,7 +284,7 @@ def edit_shelf(shelf_id):
flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]), flash(_(u"A public shelf with the name '%(title)s' already exists.", title=to_save["title"]),
category="error") category="error")
else: else:
is_shelf_name_unique = ub.session.query(ub.Shelf) \ is_shelf_name_unique = g.ubsession.query(ub.Shelf) \
.filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) & .filter((ub.Shelf.name == to_save["title"]) & (ub.Shelf.is_public == 0) &
(ub.Shelf.user_id == int(current_user.id)))\ (ub.Shelf.user_id == int(current_user.id)))\
.filter(ub.Shelf.id != shelf_id)\ .filter(ub.Shelf.id != shelf_id)\
@ -302,13 +302,13 @@ def edit_shelf(shelf_id):
else: else:
shelf.is_public = 0 shelf.is_public = 0
try: try:
ub.session.commit() g.ubsession.commit()
flash(_(u"Shelf %(title)s changed", title=to_save["title"]), category="success") flash(_(u"Shelf %(title)s changed", title=to_save["title"]), category="success")
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
except Exception: except Exception:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"There was an error"), category="error") flash(_(u"There was an error"), category="error")
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"), page="shelfedit") return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"), page="shelfedit")
else: else:
@ -319,10 +319,10 @@ def delete_shelf_helper(cur_shelf):
if not cur_shelf or not check_shelf_edit_permissions(cur_shelf): if not cur_shelf or not check_shelf_edit_permissions(cur_shelf):
return return
shelf_id = cur_shelf.id shelf_id = cur_shelf.id
ub.session.delete(cur_shelf) g.ubsession.delete(cur_shelf)
ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).delete() g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).delete()
ub.session.add(ub.ShelfArchive(uuid=cur_shelf.uuid, user_id=cur_shelf.user_id)) g.ubsession.add(ub.ShelfArchive(uuid=cur_shelf.uuid, user_id=cur_shelf.user_id))
ub.session.commit() g.ubsession.commit()
log.info("successfully deleted %s", cur_shelf) log.info("successfully deleted %s", cur_shelf)
@ -330,11 +330,11 @@ def delete_shelf_helper(cur_shelf):
@shelf.route("/shelf/delete/<int:shelf_id>") @shelf.route("/shelf/delete/<int:shelf_id>")
@login_required @login_required
def delete_shelf(shelf_id): def delete_shelf(shelf_id):
cur_shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() cur_shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
try: try:
delete_shelf_helper(cur_shelf) delete_shelf_helper(cur_shelf)
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
return redirect(url_for('web.index')) return redirect(url_for('web.index'))
@ -343,14 +343,14 @@ def delete_shelf(shelf_id):
@shelf.route("/shelf/<int:shelf_id>/<int:shelf_type>") @shelf.route("/shelf/<int:shelf_id>/<int:shelf_type>")
@login_required_if_no_ano @login_required_if_no_ano
def show_shelf(shelf_type, shelf_id): def show_shelf(shelf_type, shelf_id):
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
result = list() result = list()
# user is allowed to access shelf # user is allowed to access shelf
if shelf and check_shelf_view_permissions(shelf): if shelf and check_shelf_view_permissions(shelf):
page = "shelf.html" if shelf_type == 1 else 'shelfdown.html' page = "shelf.html" if shelf_type == 1 else 'shelfdown.html'
books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id)\ books_in_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id)\
.order_by(ub.BookShelf.order.asc()).all() .order_by(ub.BookShelf.order.asc()).all()
for book in books_in_shelf: for book in books_in_shelf:
cur_book = calibre_db.get_filtered_book(book.book_id) cur_book = calibre_db.get_filtered_book(book.book_id)
@ -361,10 +361,10 @@ def show_shelf(shelf_type, shelf_id):
if not cur_book: if not cur_book:
log.info('Not existing book %s in %s deleted', book.book_id, shelf) log.info('Not existing book %s in %s deleted', book.book_id, shelf)
try: try:
ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == book.book_id).delete() g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.book_id == book.book_id).delete()
ub.session.commit() g.ubsession.commit()
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
return render_title_template(page, entries=result, title=_(u"Shelf: '%(name)s'", name=shelf.name), return render_title_template(page, entries=result, title=_(u"Shelf: '%(name)s'", name=shelf.name),
shelf=shelf, page="shelf") shelf=shelf, page="shelf")
@ -378,7 +378,7 @@ def show_shelf(shelf_type, shelf_id):
def order_shelf(shelf_id): def order_shelf(shelf_id):
if request.method == "POST": if request.method == "POST":
to_save = request.form.to_dict() to_save = request.form.to_dict()
books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by( books_in_shelf = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by(
ub.BookShelf.order.asc()).all() ub.BookShelf.order.asc()).all()
counter = 0 counter = 0
for book in books_in_shelf: for book in books_in_shelf:
@ -386,15 +386,15 @@ def order_shelf(shelf_id):
counter += 1 counter += 1
# if order diffrent from before -> shelf.last_modified = datetime.utcnow() # if order diffrent from before -> shelf.last_modified = datetime.utcnow()
try: try:
ub.session.commit() g.ubsession.commit()
except (OperationalError, InvalidRequestError): except (OperationalError, InvalidRequestError):
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Settings DB is not Writeable"), category="error") flash(_(u"Settings DB is not Writeable"), category="error")
shelf = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first() shelf = g.ubsession.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
result = list() result = list()
if shelf and check_shelf_view_permissions(shelf): if shelf and check_shelf_view_permissions(shelf):
books_in_shelf2 = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \ books_in_shelf2 = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id) \
.order_by(ub.BookShelf.order.asc()).all() .order_by(ub.BookShelf.order.asc()).all()
for book in books_in_shelf2: for book in books_in_shelf2:
cur_book = calibre_db.get_filtered_book(book.book_id) cur_book = calibre_db.get_filtered_book(book.book_id)

31
cps/ub.py
View File

@ -46,12 +46,13 @@ from sqlalchemy import String, Integer, SmallInteger, Boolean, DateTime, Float,
from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.attributes import flag_modified from sqlalchemy.orm.attributes import flag_modified
from sqlalchemy.orm import backref, relationship, sessionmaker, Session from sqlalchemy.orm import backref, relationship, sessionmaker, Session
from sqlalchemy.orm import relationship, scoped_session
from werkzeug.security import generate_password_hash from werkzeug.security import generate_password_hash
from . import constants from . import constants
session = None Scoped_Session = None
app_DB_path = None app_DB_path = None
Base = declarative_base() Base = declarative_base()
searched_ids = {} searched_ids = {}
@ -219,9 +220,9 @@ class UserBase:
except AttributeError: except AttributeError:
pass pass
try: try:
session.commit() g.ubsession.commit()
except (exc.OperationalError, exc.InvalidRequestError): except (exc.OperationalError, exc.InvalidRequestError):
session.rollback() g.ubsession.rollback()
# ToDo: Error message # ToDo: Error message
def __repr__(self): def __repr__(self):
@ -279,6 +280,7 @@ class Anonymous(AnonymousUserMixin, UserBase):
self.loadSettings() self.loadSettings()
def loadSettings(self): def loadSettings(self):
session = Scoped_Session()
data = session.query(User).filter(User.role.op('&')(constants.ROLE_ANONYMOUS) == constants.ROLE_ANONYMOUS)\ data = session.query(User).filter(User.role.op('&')(constants.ROLE_ANONYMOUS) == constants.ROLE_ANONYMOUS)\
.first() # type: User .first() # type: User
self.nickname = data.nickname self.nickname = data.nickname
@ -297,6 +299,7 @@ class Anonymous(AnonymousUserMixin, UserBase):
# Initialize flask_session once # Initialize flask_session once
if 'view' not in flask_session: if 'view' not in flask_session:
flask_session['view']={} flask_session['view']={}
session.close()
def role_admin(self): def role_admin(self):
@ -673,18 +676,18 @@ def clean_database(session):
# Save downloaded books per user in calibre-web's own database # Save downloaded books per user in calibre-web's own database
def update_download(book_id, user_id): def update_download(book_id, user_id):
check = session.query(Downloads).filter(Downloads.user_id == user_id).filter(Downloads.book_id == book_id).first() check = g.ubsession.query(Downloads).filter(Downloads.user_id == user_id).filter(Downloads.book_id == book_id).first()
if not check: if not check:
new_download = Downloads(user_id=user_id, book_id=book_id) new_download = Downloads(user_id=user_id, book_id=book_id)
session.add(new_download) g.ubsession.add(new_download)
session.commit() g.ubsession.commit()
# Delete non exisiting downloaded books in calibre-web's own database # Delete non exisiting downloaded books in calibre-web's own database
def delete_download(book_id): def delete_download(book_id):
session.query(Downloads).filter(book_id == Downloads.book_id).delete() g.ubsession.query(Downloads).filter(book_id == Downloads.book_id).delete()
session.commit() g.ubsession.commit()
# Generate user Guest (translated text), as anonymous user, no rights # Generate user Guest (translated text), as anonymous user, no rights
def create_anonymous_user(session): def create_anonymous_user(session):
@ -716,18 +719,21 @@ def create_admin_user(session):
except Exception: except Exception:
session.rollback() session.rollback()
def create_session():
pass
def init_db(app_db_path): def init_db(app_db_path):
# Open session for database connection # Open session for database connection
global session global Scoped_Session
global app_DB_path global app_DB_path
global engine
app_DB_path = app_db_path app_DB_path = app_db_path
engine = create_engine(u'sqlite:///{0}'.format(app_db_path), echo=False) engine = create_engine(u'sqlite:///{0}'.format(app_db_path), echo=False)
Session = sessionmaker() Scoped_Session = scoped_session(sessionmaker()) # sessionmaker()
Session.configure(bind=engine) Scoped_Session.configure(bind=engine)
session = Session() session = Scoped_Session()
if os.path.exists(app_db_path): if os.path.exists(app_db_path):
Base.metadata.create_all(engine) Base.metadata.create_all(engine)
@ -737,6 +743,7 @@ def init_db(app_db_path):
Base.metadata.create_all(engine) Base.metadata.create_all(engine)
create_admin_user(session) create_admin_user(session)
create_anonymous_user(session) create_anonymous_user(session)
session.close()
def dispose(): def dispose():

98
cps/web.py
View File

@ -139,6 +139,7 @@ def add_security_headers(resp):
resp.headers['X-XSS-Protection'] = '1; mode=block' resp.headers['X-XSS-Protection'] = '1; mode=block'
resp.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains' resp.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
# log.debug(request.full_path) # log.debug(request.full_path)
g.ubsession.close()
return resp return resp
web = Blueprint('web', __name__) web = Blueprint('web', __name__)
@ -147,12 +148,13 @@ log = logger.create()
# ################################### Login logic and rights management ############################################### # ################################### Login logic and rights management ###############################################
def _fetch_user_by_name(username): def _fetch_user_by_name(username):
return ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == username.lower()).first() return g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) == username.lower()).first()
@lm.user_loader @lm.user_loader
def load_user(user_id): def load_user(user_id):
return ub.session.query(ub.User).filter(ub.User.id == int(user_id)).first() g.ubsession = ub.Scoped_Session()
return g.ubsession.query(ub.User).filter(ub.User.id == int(user_id)).first()
@lm.request_loader @lm.request_loader
@ -291,6 +293,7 @@ def edit_required(f):
@web.before_app_request @web.before_app_request
def before_request(): def before_request():
g.ubsession = ub.Scoped_Session()
if current_user.is_authenticated: if current_user.is_authenticated:
confirm_login() confirm_login()
g.constants = constants g.constants = constants
@ -300,7 +303,7 @@ def before_request():
g.allow_upload = config.config_uploading g.allow_upload = config.config_uploading
g.current_theme = config.config_theme g.current_theme = config.config_theme
g.config_authors_max = config.config_authors_max g.config_authors_max = config.config_authors_max
g.shelves_access = ub.session.query(ub.Shelf).filter( g.shelves_access = g.ubsession.query(ub.Shelf).filter(
or_(ub.Shelf.is_public == 1, ub.Shelf.user_id == current_user.id)).order_by(ub.Shelf.name).all() or_(ub.Shelf.is_public == 1, ub.Shelf.user_id == current_user.id)).order_by(ub.Shelf.name).all()
if not config.db_configured and request.endpoint not in ( if not config.db_configured and request.endpoint not in (
'admin.basic_configuration', 'login') and '/static/' not in request.path: 'admin.basic_configuration', 'login') and '/static/' not in request.path:
@ -350,8 +353,7 @@ def import_ldap_users():
username = user_data[user_login_field][0].decode('utf-8') username = user_data[user_login_field][0].decode('utf-8')
# check for duplicate username # check for duplicate username
if ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == username.lower()).first(): if g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) == username.lower()).first():
# if ub.session.query(ub.User).filter(ub.User.nickname == username).first():
log.warning("LDAP User %s Already in Database", user_data) log.warning("LDAP User %s Already in Database", user_data)
continue continue
@ -365,7 +367,7 @@ def import_ldap_users():
log.debug('No Mail Field Found in LDAP Response') log.debug('No Mail Field Found in LDAP Response')
useremail = username + '@email.com' useremail = username + '@email.com'
# check for duplicate email # check for duplicate email
if ub.session.query(ub.User).filter(func.lower(ub.User.email) == useremail.lower()).first(): if g.ubsession.query(ub.User).filter(func.lower(ub.User.email) == useremail.lower()).first():
log.warning("LDAP Email %s Already in Database", user_data) log.warning("LDAP Email %s Already in Database", user_data)
continue continue
content = ub.User() content = ub.User()
@ -379,13 +381,13 @@ def import_ldap_users():
content.denied_tags = config.config_denied_tags content.denied_tags = config.config_denied_tags
content.allowed_column_value = config.config_allowed_column_value content.allowed_column_value = config.config_allowed_column_value
content.denied_column_value = config.config_denied_column_value content.denied_column_value = config.config_denied_column_value
ub.session.add(content) g.ubsession.add(content)
try: try:
ub.session.commit() g.ubsession.commit()
imported +=1 imported +=1
except Exception as e: except Exception as e:
log.warning("Failed to create LDAP user: %s - %s", user, e) log.warning("Failed to create LDAP user: %s - %s", user, e)
ub.session.rollback() g.ubsession.rollback()
showtext['text'] = _(u'Failed to Create at Least One LDAP User') showtext['text'] = _(u'Failed to Create at Least One LDAP User')
else: else:
log.warning("LDAP User: %s Not Found", user) log.warning("LDAP User: %s Not Found", user)
@ -428,19 +430,19 @@ def get_email_status_json():
@login_required @login_required
def bookmark(book_id, book_format): def bookmark(book_id, book_format):
bookmark_key = request.form["bookmark"] bookmark_key = request.form["bookmark"]
ub.session.query(ub.Bookmark).filter(and_(ub.Bookmark.user_id == int(current_user.id), g.ubsession.query(ub.Bookmark).filter(and_(ub.Bookmark.user_id == int(current_user.id),
ub.Bookmark.book_id == book_id, ub.Bookmark.book_id == book_id,
ub.Bookmark.format == book_format)).delete() ub.Bookmark.format == book_format)).delete()
if not bookmark_key: if not bookmark_key:
ub.session.commit() g.ubsession.commit()
return "", 204 return "", 204
lbookmark = ub.Bookmark(user_id=current_user.id, lbookmark = ub.Bookmark(user_id=current_user.id,
book_id=book_id, book_id=book_id,
format=book_format, format=book_format,
bookmark_key=bookmark_key) bookmark_key=bookmark_key)
ub.session.merge(lbookmark) g.ubsession.merge(lbookmark)
ub.session.commit() g.ubsession.commit()
return "", 201 return "", 201
@ -448,7 +450,7 @@ def bookmark(book_id, book_format):
@login_required @login_required
def toggle_read(book_id): def toggle_read(book_id):
if not config.config_read_column: if not config.config_read_column:
book = ub.session.query(ub.ReadBook).filter(and_(ub.ReadBook.user_id == int(current_user.id), book = g.ubsession.query(ub.ReadBook).filter(and_(ub.ReadBook.user_id == int(current_user.id),
ub.ReadBook.book_id == book_id)).first() ub.ReadBook.book_id == book_id)).first()
if book: if book:
if book.read_status == ub.ReadBook.STATUS_FINISHED: if book.read_status == ub.ReadBook.STATUS_FINISHED:
@ -464,8 +466,8 @@ def toggle_read(book_id):
kobo_reading_state.current_bookmark = ub.KoboBookmark() kobo_reading_state.current_bookmark = ub.KoboBookmark()
kobo_reading_state.statistics = ub.KoboStatistics() kobo_reading_state.statistics = ub.KoboStatistics()
book.kobo_reading_state = kobo_reading_state book.kobo_reading_state = kobo_reading_state
ub.session.merge(book) g.ubsession.merge(book)
ub.session.commit() g.ubsession.commit()
else: else:
try: try:
calibre_db.update_title_sort(config) calibre_db.update_title_sort(config)
@ -490,7 +492,7 @@ def toggle_read(book_id):
@web.route("/ajax/togglearchived/<int:book_id>", methods=['POST']) @web.route("/ajax/togglearchived/<int:book_id>", methods=['POST'])
@login_required @login_required
def toggle_archived(book_id): def toggle_archived(book_id):
archived_book = ub.session.query(ub.ArchivedBook).filter(and_(ub.ArchivedBook.user_id == int(current_user.id), archived_book = g.ubsession.query(ub.ArchivedBook).filter(and_(ub.ArchivedBook.user_id == int(current_user.id),
ub.ArchivedBook.book_id == book_id)).first() ub.ArchivedBook.book_id == book_id)).first()
if archived_book: if archived_book:
archived_book.is_archived = not archived_book.is_archived archived_book.is_archived = not archived_book.is_archived
@ -498,8 +500,8 @@ def toggle_archived(book_id):
else: else:
archived_book = ub.ArchivedBook(user_id=current_user.id, book_id=book_id) archived_book = ub.ArchivedBook(user_id=current_user.id, book_id=book_id)
archived_book.is_archived = True archived_book.is_archived = True
ub.session.merge(archived_book) g.ubsession.merge(archived_book)
ub.session.commit() g.ubsession.commit()
return "" return ""
@ -738,7 +740,7 @@ def render_hot_books(page):
else: else:
random = false() random = false()
off = int(int(config.config_books_per_page) * (page - 1)) off = int(int(config.config_books_per_page) * (page - 1))
all_books = ub.session.query(ub.Downloads, func.count(ub.Downloads.book_id)).order_by( all_books = g.ubsession.query(ub.Downloads, func.count(ub.Downloads.book_id)).order_by(
func.count(ub.Downloads.book_id).desc()).group_by(ub.Downloads.book_id) func.count(ub.Downloads.book_id).desc()).group_by(ub.Downloads.book_id)
hot_books = all_books.offset(off).limit(config.config_books_per_page) hot_books = all_books.offset(off).limit(config.config_books_per_page)
entries = list() entries = list()
@ -749,8 +751,6 @@ def render_hot_books(page):
entries.append(downloadBook) entries.append(downloadBook)
else: else:
ub.delete_download(book.Downloads.book_id) ub.delete_download(book.Downloads.book_id)
# ub.session.query(ub.Downloads).filter(book.Downloads.book_id == ub.Downloads.book_id).delete()
# ub.session.commit()
numBooks = entries.__len__() numBooks = entries.__len__()
pagination = Pagination(page, config.config_books_per_page, numBooks) pagination = Pagination(page, config.config_books_per_page, numBooks)
return render_title_template('index.html', random=random, entries=entries, pagination=pagination, return render_title_template('index.html', random=random, entries=entries, pagination=pagination,
@ -953,7 +953,7 @@ def render_read_books(page, are_read, as_xml=False, order=None, *args, **kwargs)
def render_archived_books(page, order): def render_archived_books(page, order):
order = order or [] order = order or []
archived_books = ( archived_books = (
ub.session.query(ub.ArchivedBook) g.ubsession.query(ub.ArchivedBook)
.filter(ub.ArchivedBook.user_id == int(current_user.id)) .filter(ub.ArchivedBook.user_id == int(current_user.id))
.filter(ub.ArchivedBook.is_archived == True) .filter(ub.ArchivedBook.is_archived == True)
.all() .all()
@ -1085,7 +1085,7 @@ def update_table_settings():
flag_modified(current_user, "view_settings") flag_modified(current_user, "view_settings")
except AttributeError: except AttributeError:
pass pass
ub.session.commit() g.ubsession.commit()
except InvalidRequestError: except InvalidRequestError:
log.error("Invalid request received: %r ", request, ) log.error("Invalid request received: %r ", request, )
return "Invalid request", 400 return "Invalid request", 400
@ -1550,9 +1550,9 @@ def register():
return render_title_template('register.html', title=_(u"register"), page="register") return render_title_template('register.html', title=_(u"register"), page="register")
existing_user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == nickname existing_user = g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) == nickname
.lower()).first() .lower()).first()
existing_email = ub.session.query(ub.User).filter(ub.User.email == to_save["email"].lower()).first() existing_email = g.ubsession.query(ub.User).filter(ub.User.email == to_save["email"].lower()).first()
if not existing_user and not existing_email: if not existing_user and not existing_email:
content = ub.User() content = ub.User()
if check_valid_domain(to_save["email"]): if check_valid_domain(to_save["email"]):
@ -1563,13 +1563,13 @@ def register():
content.role = config.config_default_role content.role = config.config_default_role
content.sidebar_view = config.config_default_show content.sidebar_view = config.config_default_show
try: try:
ub.session.add(content) g.ubsession.add(content)
ub.session.commit() g.ubsession.commit()
if feature_support['oauth']: if feature_support['oauth']:
register_user_with_oauth(content) register_user_with_oauth(content)
send_registration_mail(to_save["email"], nickname, password) send_registration_mail(to_save["email"], nickname, password)
except Exception: except Exception:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"An unknown error occurred. Please try again later."), category="error") flash(_(u"An unknown error occurred. Please try again later."), category="error")
return render_title_template('register.html', title=_(u"register"), page="register") return render_title_template('register.html', title=_(u"register"), page="register")
else: else:
@ -1599,7 +1599,7 @@ def login():
flash(_(u"Cannot activate LDAP authentication"), category="error") flash(_(u"Cannot activate LDAP authentication"), category="error")
if request.method == "POST": if request.method == "POST":
form = request.form.to_dict() form = request.form.to_dict()
user = ub.session.query(ub.User).filter(func.lower(ub.User.nickname) == form['username'].strip().lower()) \ user = g.ubsession.query(ub.User).filter(func.lower(ub.User.nickname) == form['username'].strip().lower()) \
.first() .first()
if config.config_login_type == constants.LOGIN_LDAP and services.ldap and user and form['password'] != "": if config.config_login_type == constants.LOGIN_LDAP and services.ldap and user and form['password'] != "":
login_result, error = services.ldap.bind_user(form['username'], form['password']) login_result, error = services.ldap.bind_user(form['username'], form['password'])
@ -1675,8 +1675,8 @@ def logout():
@remote_login_required @remote_login_required
def remote_login(): def remote_login():
auth_token = ub.RemoteAuthToken() auth_token = ub.RemoteAuthToken()
ub.session.add(auth_token) g.ubsession.add(auth_token)
ub.session.commit() g.ubsession.commit()
verify_url = url_for('web.verify_token', token=auth_token.auth_token, _external=true) verify_url = url_for('web.verify_token', token=auth_token.auth_token, _external=true)
log.debug(u"Remot Login request with token: %s", auth_token.auth_token) log.debug(u"Remot Login request with token: %s", auth_token.auth_token)
@ -1688,7 +1688,7 @@ def remote_login():
@remote_login_required @remote_login_required
@login_required @login_required
def verify_token(token): def verify_token(token):
auth_token = ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first() auth_token = g.ubsession.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first()
# Token not found # Token not found
if auth_token is None: if auth_token is None:
@ -1698,8 +1698,8 @@ def verify_token(token):
# Token expired # Token expired
if datetime.now() > auth_token.expiration: if datetime.now() > auth_token.expiration:
ub.session.delete(auth_token) g.ubsession.delete(auth_token)
ub.session.commit() g.ubsession.commit()
flash(_(u"Token has expired"), category="error") flash(_(u"Token has expired"), category="error")
log.error(u"Remote Login token expired") log.error(u"Remote Login token expired")
@ -1708,7 +1708,7 @@ def verify_token(token):
# Update token with user information # Update token with user information
auth_token.user_id = current_user.id auth_token.user_id = current_user.id
auth_token.verified = True auth_token.verified = True
ub.session.commit() g.ubsession.commit()
flash(_(u"Success! Please return to your device"), category="success") flash(_(u"Success! Please return to your device"), category="success")
log.debug(u"Remote Login token for userid %s verified", auth_token.user_id) log.debug(u"Remote Login token for userid %s verified", auth_token.user_id)
@ -1719,7 +1719,7 @@ def verify_token(token):
@remote_login_required @remote_login_required
def token_verified(): def token_verified():
token = request.form['token'] token = request.form['token']
auth_token = ub.session.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first() auth_token = g.ubsession.query(ub.RemoteAuthToken).filter(ub.RemoteAuthToken.auth_token == token).first()
data = {} data = {}
@ -1730,8 +1730,8 @@ def token_verified():
# Token expired # Token expired
elif datetime.now() > auth_token.expiration: elif datetime.now() > auth_token.expiration:
ub.session.delete(auth_token) g.ubsession.delete(auth_token)
ub.session.commit() g.ubsession.commit()
data['status'] = 'error' data['status'] = 'error'
data['message'] = _(u"Token has expired") data['message'] = _(u"Token has expired")
@ -1740,11 +1740,11 @@ def token_verified():
data['status'] = 'not_verified' data['status'] = 'not_verified'
else: else:
user = ub.session.query(ub.User).filter(ub.User.id == auth_token.user_id).first() user = g.ubsession.query(ub.User).filter(ub.User.id == auth_token.user_id).first()
login_user(user) login_user(user)
ub.session.delete(auth_token) g.ubsession.delete(auth_token)
ub.session.commit() g.ubsession.commit()
data['status'] = 'success' data['status'] = 'success'
log.debug(u"Remote Login for userid %s succeded", user.id) log.debug(u"Remote Login for userid %s succeded", user.id)
@ -1800,7 +1800,7 @@ def profile():
current_user.email = to_save["email"] current_user.email = to_save["email"]
if "nickname" in to_save and to_save["nickname"] != current_user.nickname: if "nickname" in to_save and to_save["nickname"] != current_user.nickname:
# Query User nickname, if not existing, change # Query User nickname, if not existing, change
if not ub.session.query(ub.User).filter(ub.User.nickname == to_save["nickname"]).scalar(): if not g.ubsession.query(ub.User).filter(ub.User.nickname == to_save["nickname"]).scalar():
current_user.nickname = to_save["nickname"] current_user.nickname = to_save["nickname"]
else: else:
flash(_(u"This username is already taken"), category="error") flash(_(u"This username is already taken"), category="error")
@ -1829,11 +1829,11 @@ def profile():
current_user.sidebar_view += constants.DETAIL_RANDOM current_user.sidebar_view += constants.DETAIL_RANDOM
try: try:
ub.session.commit() g.ubsession.commit()
flash(_(u"Profile updated"), category="success") flash(_(u"Profile updated"), category="success")
log.debug(u"Profile updated") log.debug(u"Profile updated")
except IntegrityError: except IntegrityError:
ub.session.rollback() g.ubsession.rollback()
flash(_(u"Found an existing account for this e-mail address."), category="error") flash(_(u"Found an existing account for this e-mail address."), category="error")
log.debug(u"Found an existing account for this e-mail address.") log.debug(u"Found an existing account for this e-mail address.")
'''return render_title_template("user_edit.html", '''return render_title_template("user_edit.html",
@ -1872,7 +1872,7 @@ def read_book(book_id, book_format):
# check if book has bookmark # check if book has bookmark
bookmark = None bookmark = None
if current_user.is_authenticated: if current_user.is_authenticated:
bookmark = ub.session.query(ub.Bookmark).filter(and_(ub.Bookmark.user_id == int(current_user.id), bookmark = g.ubsession.query(ub.Bookmark).filter(and_(ub.Bookmark.user_id == int(current_user.id),
ub.Bookmark.book_id == book_id, ub.Bookmark.book_id == book_id,
ub.Bookmark.format == book_format.upper())).first() ub.Bookmark.format == book_format.upper())).first()
if book_format.lower() == "epub": if book_format.lower() == "epub":
@ -1924,13 +1924,13 @@ def show_book(book_id):
isoLanguages.get(part3=entries.languages[index].lang_code).name) isoLanguages.get(part3=entries.languages[index].lang_code).name)
cc = get_cc_columns(filter_config_custom_read=True) cc = get_cc_columns(filter_config_custom_read=True)
book_in_shelfs = [] book_in_shelfs = []
shelfs = ub.session.query(ub.BookShelf).filter(ub.BookShelf.book_id == book_id).all() shelfs = g.ubsession.query(ub.BookShelf).filter(ub.BookShelf.book_id == book_id).all()
for entry in shelfs: for entry in shelfs:
book_in_shelfs.append(entry.shelf) book_in_shelfs.append(entry.shelf)
if not current_user.is_anonymous: if not current_user.is_anonymous:
if not config.config_read_column: if not config.config_read_column:
matching_have_read_book = ub.session.query(ub.ReadBook). \ matching_have_read_book = g.ubsession.query(ub.ReadBook). \
filter(and_(ub.ReadBook.user_id == int(current_user.id), ub.ReadBook.book_id == book_id)).all() filter(and_(ub.ReadBook.user_id == int(current_user.id), ub.ReadBook.book_id == book_id)).all()
have_read = len( have_read = len(
matching_have_read_book) > 0 and matching_have_read_book[0].read_status == ub.ReadBook.STATUS_FINISHED matching_have_read_book) > 0 and matching_have_read_book[0].read_status == ub.ReadBook.STATUS_FINISHED
@ -1942,7 +1942,7 @@ def show_book(book_id):
log.error("Custom Column No.%d is not existing in calibre database", config.config_read_column) log.error("Custom Column No.%d is not existing in calibre database", config.config_read_column)
have_read = None have_read = None
archived_book = ub.session.query(ub.ArchivedBook).\ archived_book = g.ubsession.query(ub.ArchivedBook).\
filter(and_(ub.ArchivedBook.user_id == int(current_user.id), filter(and_(ub.ArchivedBook.user_id == int(current_user.id),
ub.ArchivedBook.book_id == book_id)).first() ub.ArchivedBook.book_id == book_id)).first()
is_archived = archived_book and archived_book.is_archived is_archived = archived_book and archived_book.is_archived