NunoSempere/calibre-web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bugfix for accessing config database

Browse Source 
Title now displaed on every page
Title can be changed from within application
This commit is contained in:
OzzieIsaacs 2017-01-22 21:30:36 +01:00
parent 4eee58c21c
commit 75c89c28e1
8 changed files with 149 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
cps/db.py
View File

@ -5,13 +5,15 @@ from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import *
import os
# import config
import re
import ast
from ub import Config
global session
# user defined sort function for calibre databases (Series, etc.)
def title_sort(title):
# calibre sort stuff
config=Config()
title_pat = re.compile(config.config_title_regex, re.IGNORECASE)
match = title_pat.search(title)
if match:
prep = match.group(1)
@ -250,20 +252,24 @@ class Custom_Columns(Base):
display_dict = ast.literal_eval(self.display)
return display_dict
def setup_db(config):
global session
# calibre sort stuff
title_pat = re.compile(config.config_title_regex, re.IGNORECASE)
global cc_exceptions
global cc_classes
global cc_ids
global books_custom_column_links
if config.config_calibre_dir is None:
return
dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
engine = create_engine('sqlite:///{0}'.format(dbpath.encode('utf-8')), echo=False)
conn = engine.connect()
conn.connection.create_function('title_sort', 1, title_sort)
cc = conn.execute("SELECT id, datatype FROM custom_columns")
cc_ids = []
cc_exceptions = ['datetime', 'int', 'comments', 'float', 'composite', 'series']
books_custom_column_links = {}

2
cps/helper.py
View File

@ -255,7 +255,7 @@ def update_dir_stucture(book_id,calibrepath):
book.path = book.path.split(os.sep)[0] + os.sep + new_titledir
if authordir != new_authordir:
new_author_path = os.path.join(os.path.join(config.DB_ROOT, new_authordir), os.path.basename(path))
new_author_path = os.path.join(os.path.join(calibrepath, new_authordir), os.path.basename(path))
os.renames(path, new_author_path)
book.path = new_authordir + os.sep + book.path.split(os.sep)[1]
db.session.commit()

18
cps/templates/admin.html
View File

@ -15,7 +15,7 @@
<th>{{_('Passwd')}}</th>
</tr>
{% for user in content %}
{% if not user.role_anonymous() or config.ANON_BROWSE %}
{% if not user.role_anonymous() or config.config_anonbrowse %}
<tr>
<td><a href="{{url_for('edit_user', user_id=user.id)}}">{{user.nickname}}</a></td>
<td>{{user.email}}</td>
@ -56,7 +56,7 @@
<h2>{{_('Configuration')}}</h2>
<table class="table table-striped">
<tr>
<th>{{_('Log File')}}</th>
<th>{{_('Calibre DB dir')}}</th>
<th>{{_('Log Level')}}</th>
<th>{{_('Port')}}</th>
<th>{{_('Books per page')}}</th>
@ -65,13 +65,13 @@
<th>{{_('Anonymous browsing')}}</th>
</tr>
<tr>
<td>{{config.LOG_DIR}}</td>
<td>{{config.LOG_DIR}}</td>
<td>{{config.PORT}}</td>
<td>{{config.NEWEST_BOOKS}}</td>
<td>{% if config.UPLOADING %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
<td>{% if config.PUBLIC_REG %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
<td>{% if config.ANON_BROWSE %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
<td>{{config.config_calibre_dir}}</td>
<td>{{config.config_log_level}}</td>
<td>{{config.config_port}}</td>
<td>{{config.config_books_per_page}}</td>
<td>{% if config.config_uploading %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
<td>{% if config.config_public_reg %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
<td>{% if config.config_anonbrowse %}<span class="glyphicon glyphicon-ok"></span>{% else %}<span class="glyphicon glyphicon-remove"></span>{% endif %}</td>
</table>
<div class="btn btn-default"><a href="{{url_for('configuration')}}">{{_('Configuration')}}</a></div>
<h2>{{_('Administration')}}</h2>

2
cps/templates/config_edit.html
View File

@ -9,7 +9,7 @@
</div>
<div class="form-group">
<label for="config_port">{{_('Server Port')}}</label>
<input type="text" class="form-control" name="config_port" id="port" value="{% if content.config_port != None %}{{ content.config_port }}{% endif %}" autocomplete="off" required>
<input type="text" class="form-control" name="config_port" id="config_port" value="{% if content.config_port != None %}{{ content.config_port }}{% endif %}" autocomplete="off" required>
</div>
<div class="form-group">
<label for="config_calibre_web_title">{{_('Title')}}</label>

2
cps/templates/layout.html
View File

@ -1,7 +1,7 @@
<!DOCTYPE html>
<html>
<head>
<title>calibre web | {{title}}</title>
<title>{{instance}} | {{title}}</title>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

2
cps/templates/read.html
View File

@ -57,7 +57,7 @@
<!-- Full Screen -->
<!--<script src="js/libs/screenfull.min.js"></script>-->
<script src="{{ url_for('static', filename='js/libs/screenfull.min.js') }}"></script>
<script src="{{ url_for('static', filename='js/screenfull.min.js') }}"></script>
<!-- Render -->
<!--<script src="js/epub.min.js"></script>-->

18
cps/ub.py
View File

@ -7,7 +7,6 @@ from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import *
from flask_login import AnonymousUserMixin
import os
# import config
import traceback
from werkzeug.security import generate_password_hash
from flask_babel import gettext as _
@ -98,6 +97,9 @@ class UserBase():
class Config():
def __init__(self):
self.config_main_dir=os.path.join(os.path.normpath(os.path.dirname(
os.path.realpath(__file__)) + os.sep + ".." + os.sep))
self.db_configured=None
self.loadSettings()
def loadSettings(self):
@ -112,6 +114,18 @@ class Config():
self.config_uploading = data.config_uploading
self.config_anonbrowse = data.config_anonbrowse
self.config_public_reg = data.config_public_reg
if self.config_calibre_dir is not None and (self.db_configured is None or self.db_configured is True):
self.db_configured=True
else:
self.db_configured = False
@property
def get_main_dir(self):
return self.config_main_dir
@property
def is_Calibre_Configured(self):
return self.db_configured
class User(UserBase,Base):
@ -135,7 +149,7 @@ class User(UserBase,Base):
class Anonymous(AnonymousUserMixin,UserBase):
anon_browse = None
# anon_browse = None
def __init__(self):
self.loadSettings()

203
cps/web.py
View File

@ -46,7 +46,6 @@ except ImportError, e:
from cgi import escape
########################################## Global variables ########################################################
global global_task
global_task = None
@ -124,6 +123,10 @@ babel = Babel(app)
import uploader
# establish connection to calibre-db
config=ub.Config()
db.setup_db(config)
lm = LoginManager(app)
lm.init_app(app)
lm.login_view = 'login'
@ -131,9 +134,6 @@ lm.anonymous_user = ub.Anonymous
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
# establish connection to calibre-db
config=ub.Config()
db.setup_db(config)
@babel.localeselector
@ -293,7 +293,6 @@ def admin_required(f):
if current_user.role_admin():
return f(*args, **kwargs)
abort(403)
return inner
def unconfigured(f):
@ -302,10 +301,9 @@ def unconfigured(f):
"""
@wraps(f)
def inner(*args, **kwargs):
if not config.config_calibre_dir:
if config.is_Calibre_Configured:
return f(*args, **kwargs)
abort(403)
return inner
@ -315,7 +313,6 @@ def download_required(f):
if current_user.role_download() or current_user.role_admin():
return f(*args, **kwargs)
abort(403)
return inner
@ -325,7 +322,6 @@ def upload_required(f):
if current_user.role_upload() or current_user.role_admin():
return f(*args, **kwargs)
abort(403)
return inner
@ -335,7 +331,6 @@ def edit_required(f):
if current_user.role_edit() or current_user.role_admin():
return f(*args, **kwargs)
abort(403)
return inner
@ -410,6 +405,10 @@ def modify_database_object(input_elements, db_book_object, db_object, db_session
# add element to book
db_book_object.append(new_element)
def render_title_template(*args, **kwargs):
return render_template(instance=config.config_calibre_web_title, *args, **kwargs)
@app.before_request
def before_request():
@ -418,9 +417,7 @@ def before_request():
g.allow_registration = config.config_public_reg
g.allow_upload = config.config_uploading
'''#################################################################################################################
########################################## Routing functions #######################################################
#################################################################################################################'''
@app.route("/opds")
@requires_basic_auth_if_no_ano
@ -755,8 +752,10 @@ def get_matching_tags():
@app.route('/page/<int:page>')
@login_required_if_no_ano
def index(page):
if config.is_Calibre_Configured == False:
return redirect(url_for('basic_configuration'))
entries, random, pagination = fill_indexpage(page, db.Books, True, db.Books.timestamp.desc())
return render_template('index.html', random=random, entries=entries, pagination=pagination,
return render_title_template('index.html', random=random, entries=entries, pagination=pagination,
title=_(u"Latest Books"))
@ -769,7 +768,7 @@ def hot_books(page):
else:
filter = True
if current_user.show_random_books():
random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.RANDOM_BOOKS)
random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.config_random_books)
else:
random = false
off = int(int(config.config_books_per_page) * (page - 1))
@ -781,7 +780,7 @@ def hot_books(page):
entries.append(db.session.query(db.Books).filter(filter).filter(db.Books.id == book.Downloads.book_id).first())
numBooks = entries.__len__()
pagination = Pagination(page, config.config_books_per_page, numBooks)
return render_template('index.html', random=random, entries=entries, pagination=pagination,
return render_title_template('index.html', random=random, entries=entries, pagination=pagination,
title=_(u"Hot Books (most downloaded)"))
@ -790,7 +789,7 @@ def hot_books(page):
@login_required_if_no_ano
def discover(page):
entries, random, pagination = fill_indexpage(page, db.Books, func.randomblob(2), db.Books.timestamp.desc())
return render_template('discover.html', entries=entries, pagination=pagination, title=_(u"Random Books"))
return render_title_template('discover.html', entries=entries, pagination=pagination, instance=config.config_calibre_web_title, title=_(u"Random Books"))
@app.route("/author")
@ -803,7 +802,7 @@ def author_list():
entries = db.session.query(db.Authors, func.count('books_authors_link.book').label('count')).join(
db.books_authors_link).join(db.Books).filter(
filter).group_by('books_authors_link.author').order_by(db.Authors.sort).all()
return render_template('list.html', entries=entries, folder='author', title=_(u"Author list"))
return render_title_template('list.html', entries=entries, folder='author', title=_(u"Author list"))
@app.route("/author/<name>")
@ -814,13 +813,13 @@ def author(name):
else:
filter = True
if current_user.show_random_books():
random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.RANDOM_BOOKS)
random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.config_random_books)
else:
random = false
entries = db.session.query(db.Books).filter(db.Books.authors.any(db.Authors.name.like("%" + name + "%"))).filter(
filter).all()
return render_template('index.html', random=random, entries=entries, title=_(u"Author: %(nam)s", nam=name))
return render_title_template('index.html', random=random, entries=entries,title=_(u"Author: %(nam)s", nam=name))
@app.route("/series")
@ -833,7 +832,7 @@ def series_list():
entries = db.session.query(db.Series, func.count('books_series_link.book').label('count')).join(
db.books_series_link).join(db.Books).filter(
filter).group_by('books_series_link.series').order_by(db.Series.sort).all()
return render_template('list.html', entries=entries, folder='series', title=_(u"Series list"))
return render_title_template('list.html', entries=entries, folder='series', title=_(u"Series list"))
@app.route("/series/<name>/", defaults={'page': 1})
@ -843,7 +842,7 @@ def series(name, page):
entries, random, pagination = fill_indexpage(page, db.Books, db.Books.series.any(db.Series.name == name),
db.Books.series_index)
if entries:
return render_template('index.html', random=random, pagination=pagination, entries=entries,
return render_title_template('index.html', random=random, pagination=pagination, entries=entries,
title=_(u"Series: %(serie)s", serie=name))
else:
flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error")
@ -876,7 +875,7 @@ def language_overview():
lang_counter = db.session.query(db.books_languages_link,
func.count('books_languages_link.book').label('bookcount')).group_by(
'books_languages_link.lang_code').all()
return render_template('languages.html', languages=languages, lang_counter=lang_counter,
return render_title_template('languages.html', languages=languages, lang_counter=lang_counter,
title=_(u"Available languages"))
@ -891,7 +890,7 @@ def language(name, page):
name = cur_l.get_language_name(get_locale())
except:
name = _(isoLanguages.get(part3=name).name)
return render_template('index.html', random=random, entries=entries, pagination=pagination,
return render_title_template('index.html', random=random, entries=entries, pagination=pagination,
title=_(u"Language: %(name)s", name=name))
@ -905,7 +904,7 @@ def category_list():
entries = db.session.query(db.Tags, func.count('books_tags_link.book').label('count')).join(
db.books_tags_link).join(db.Books).filter(
filter).group_by('books_tags_link.tag').all()
return render_template('list.html', entries=entries, folder='category', title=_(u"Category list"))
return render_title_template('list.html', entries=entries, folder='category', title=_(u"Category list"))
@app.route("/category/<name>", defaults={'page': 1})
@ -914,7 +913,7 @@ def category_list():
def category(name, page):
entries, random, pagination = fill_indexpage(page, db.Books, db.Books.tags.any(db.Tags.name == name),
db.Books.timestamp.desc())
return render_template('index.html', random=random, entries=entries, pagination=pagination,
return render_title_template('index.html', random=random, entries=entries, pagination=pagination,
title=_(u"Category: %(name)s", name=name))
@ -940,7 +939,8 @@ def show_book(id):
for entry in shelfs:
book_in_shelfs.append(entry.shelf)
return render_template('detail.html', entry=entries, cc=cc, title=entries.title, books_shelfs=book_in_shelfs)
return render_title_template('detail.html', entry=entries, cc=cc,
title=entries.title, books_shelfs=book_in_shelfs)
else:
flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error")
return redirect(url_for("index"))
@ -959,10 +959,11 @@ def stats():
counter = len(db.session.query(db.Books).all())
authors = len(db.session.query(db.Authors).all())
Versions=uploader.book_formats.get_versions()
vendorpath = os.path.join(config.get_main_dir + "vendor" + os.sep)
if sys.platform == "win32":
kindlegen = os.path.join(config.MAIN_DIR, "vendor", u"kindlegen.exe")
kindlegen = os.path.join(vendorpath, u"kindlegen.exe")
else:
kindlegen = os.path.join(config.MAIN_DIR, "vendor", u"kindlegen")
kindlegen = os.path.join(vendorpath, u"kindlegen")
kindlegen_version=_('not installed')
if os.path.exists(kindlegen):
p = subprocess.Popen(kindlegen, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
@ -971,7 +972,8 @@ def stats():
if re.search('Amazon kindlegen\(', lines):
Versions['KindlegenVersion'] = lines
Versions['PythonVersion']=sys.version
return render_template('stats.html', bookcounter=counter, authorcounter=authors, Versions=Versions, title=_(u"Statistics"))
return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, Versions=Versions,
title=_(u"Statistics"))
@app.route("/shutdown")
@ -1011,9 +1013,9 @@ def search():
db.Books.series.any(db.Series.name.like("%" + term + "%")),
db.Books.authors.any(db.Authors.name.like("%" + term + "%")),
db.Books.title.like("%" + term + "%"))).filter(filter).all()
return render_template('search.html', searchterm=term, entries=entries)
return render_title_template('search.html', searchterm=term, entries=entries)
else:
return render_template('search.html', searchterm="")
return render_title_template('search.html', searchterm="")
@app.route("/advanced_search", methods=["GET"])
@ -1068,7 +1070,7 @@ def advanced_search():
for language in exclude_languages_inputs:
q = q.filter(not_(db.Books.series.any(db.Languages.id == language)))
q = q.all()
return render_template('search.html', searchterm=searchterm, entries=q)
return render_title_template('search.html', searchterm=searchterm, entries=q, title=_(u"search"))
tags = db.session.query(db.Tags).order_by(db.Tags.name).all()
series = db.session.query(db.Series).order_by(db.Series.name).all()
if current_user.filter_language() == u"all":
@ -1081,13 +1083,13 @@ def advanced_search():
lang.name = _(isoLanguages.get(part3=lang.lang_code).name)
else:
languages=None
return render_template('search_form.html', tags=tags, languages=languages, series=series)
return render_title_template('search_form.html', tags=tags, languages=languages, series=series, title=_(u"search"))
@app.route("/cover/<path:cover_path>")
@login_required_if_no_ano
def get_cover(cover_path):
return send_from_directory(os.path.join(config.DB_ROOT, cover_path), "cover.jpg")
return send_from_directory(os.path.join(config.config_calibre_dir, cover_path), "cover.jpg")
@app.route("/opds/thumb_240_240/<path:book_id>")
@app.route("/opds/cover_240_240/<path:book_id>")
@ -1096,7 +1098,7 @@ def get_cover(cover_path):
@requires_basic_auth_if_no_ano
def feed_get_cover(book_id):
book = db.session.query(db.Books).filter(db.Books.id == book_id).first()
return send_from_directory(os.path.join(config.DB_ROOT, book.path), "cover.jpg")
return send_from_directory(os.path.join(config.config_calibre_dir, book.path), "cover.jpg")
@app.route("/read/<int:book_id>/<format>")
@ -1104,14 +1106,14 @@ def feed_get_cover(book_id):
def read_book(book_id, format):
book = db.session.query(db.Books).filter(db.Books.id == book_id).first()
if book:
book_dir = os.path.join(config.MAIN_DIR, "cps", "static", str(book_id))
book_dir = os.path.join(config.get_main_dir, "cps", "static", str(book_id))
if not os.path.exists(book_dir):
os.mkdir(book_dir)
if format.lower() == "epub":
# check if mimetype file is exists
mime_file = str(book_id) + "/mimetype"
if not os.path.exists(mime_file):
epub_file = os.path.join(config.DB_ROOT, book.path, book.data[0].name) + ".epub"
epub_file = os.path.join(config.config_calibre_dir, book.path, book.data[0].name) + ".epub"
if not os.path.isfile(epub_file):
raise ValueError('Error opening eBook. File does not exist: ', epub_file)
zfile = zipfile.ZipFile(epub_file)
@ -1131,28 +1133,28 @@ def read_book(book_id, format):
fd.write(zfile.read(name))
fd.close()
zfile.close()
return render_template('read.html', bookid=book_id, title=_(u"Read a Book"))
return render_title_template('read.html', bookid=book_id, title=_(u"Read a Book"))
elif format.lower() == "pdf":
all_name = str(book_id) + "/" + urllib.quote(book.data[0].name) + ".pdf"
tmp_file = os.path.join(book_dir, urllib.quote(book.data[0].name)) + ".pdf"
if not os.path.exists(tmp_file):
pdf_file = os.path.join(config.DB_ROOT, book.path, book.data[0].name) + ".pdf"
pdf_file = os.path.join(config.config_calibre_dir, book.path, book.data[0].name) + ".pdf"
copyfile(pdf_file, tmp_file)
return render_template('readpdf.html', pdffile=all_name, title=_(u"Read a Book"))
return render_title_template('readpdf.html', pdffile=all_name, title=_(u"Read a Book"))
elif format.lower() == "txt":
all_name = str(book_id) + "/" + urllib.quote(book.data[0].name) + ".txt"
tmp_file = os.path.join(book_dir, urllib.quote(book.data[0].name)) + ".txt"
if not os.path.exists(all_name):
txt_file = os.path.join(config.DB_ROOT, book.path, book.data[0].name) + ".txt"
txt_file = os.path.join(config.config_calibre_dir, book.path, book.data[0].name) + ".txt"
copyfile(txt_file, tmp_file)
return render_template('readtxt.html', txtfile=all_name, title=_(u"Read a Book"))
return render_title_template('readtxt.html', txtfile=all_name, title=_(u"Read a Book"))
elif format.lower() == "cbr":
all_name = str(book_id) + "/" + urllib.quote(book.data[0].name) + ".cbr"
tmp_file = os.path.join(book_dir, urllib.quote(book.data[0].name)) + ".cbr"
if not os.path.exists(all_name):
cbr_file = os.path.join(config.DB_ROOT, book.path, book.data[0].name) + ".cbr"
cbr_file = os.path.join(config.config_calibre_dir, book.path, book.data[0].name) + ".cbr"
copyfile(cbr_file, tmp_file)
return render_template('readcbr.html', comicfile=all_name, title=_(u"Read a Book"))
return render_title_template('readcbr.html', comicfile=all_name, title=_(u"Read a Book"))
else:
flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error")
@ -1174,7 +1176,7 @@ def get_download_link(book_id, format):
if len(author) > 0:
file_name = author + '-' + file_name
file_name = helper.get_valid_filename(file_name)
response = make_response(send_from_directory(os.path.join(config.DB_ROOT, book.path), data.name + "." + format))
response = make_response(send_from_directory(os.path.join(config.config_calibre_dir, book.path), data.name + "." + format))
try:
response.headers["Content-Type"]=mimetypes.types_map['.'+format]
except:
@ -1193,7 +1195,7 @@ def get_download_link(book_id, format):
@app.route('/register', methods=['GET', 'POST'])
def register():
error = None
if not config.PUBLIC_REG:
if not config.config_public_reg:
abort(404)
if current_user is not None and current_user.is_authenticated:
return redirect(url_for('index'))
@ -1202,7 +1204,7 @@ def register():
to_save = request.form.to_dict()
if not to_save["nickname"] or not to_save["email"] or not to_save["password"]:
flash(_(u"Please fill out all fields!"), category="error")
return render_template('register.html', title="register")
return render_title_template('register.html', title=_(u"register"))
existing_user = ub.session.query(ub.User).filter(ub.User.nickname == to_save["nickname"]).first()
existing_email = ub.session.query(ub.User).filter(ub.User.email == to_save["email"]).first()
@ -1218,26 +1220,23 @@ def register():
except:
ub.session.rollback()
flash(_(u"An unknown error occured. Please try again later."), category="error")
return render_template('register.html', title="register")
return render_title_template('register.html', title=_(u"register"))
flash("Your account has been created. Please login.", category="success")
return redirect(url_for('login'))
else:
flash(_(u"This username or email address is already in use."), category="error")
return render_template('register.html', title="register")
return render_title_template('register.html', title=_(u"register"))
return render_template('register.html', title=_(u"register"))
return render_title_template('register.html', title=_(u"register"))
@app.route('/login', methods=['GET', 'POST'])
def login():
error = None
if config.config_calibre_dir == None:
if config.is_Calibre_Configured == False:
return redirect(url_for('basic_configuration'))
if current_user is not None and current_user.is_authenticated:
return redirect(url_for('index'))
if request.method == "POST":
form = request.form.to_dict()
user = ub.session.query(ub.User).filter(ub.User.nickname == form['username'].strip()).first()
@ -1250,7 +1249,7 @@ def login():
else:
flash(_(u"Wrong Username or Password"), category="error")
return render_template('login.html', title=_(u"login"))
return render_title_template('login.html', title=_(u"login"))
@app.route('/logout')
@ -1336,7 +1335,7 @@ def create_shelf():
existing_shelf = ub.session.query(ub.Shelf).filter(or_((ub.Shelf.name == to_save["title"])&( ub.Shelf.is_public == 1),
(ub.Shelf.name == to_save["title"])& (ub.Shelf.user_id == int(current_user.id)))).first()
if existing_shelf:
flash(_(u"A shelf with the name '%(title)s' already exists.", title=to_save["title"]), category="error")
flash(_(u"A shelf with the name '%(title)s' already exists.",title=to_save["title"]), category="error")
else:
try:
ub.session.add(shelf)
@ -1344,9 +1343,9 @@ def create_shelf():
flash(_(u"Shelf %(title)s created", title=to_save["title"]), category="success")
except:
flash(_(u"There was an error"), category="error")
return render_template('shelf_edit.html', shelf=shelf, title=_(u"create a shelf"))
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"create a shelf"))
else:
return render_template('shelf_edit.html', shelf=shelf, title=_(u"create a shelf"))
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"create a shelf"))
@app.route("/shelf/edit/<int:shelf_id>", methods=["GET", "POST"])
@login_required
@ -1369,9 +1368,9 @@ def edit_shelf(shelf_id):
flash(_(u"Shelf %(title)s changed",title=to_save["title"]), category="success")
except:
flash(_(u"There was an error"), category="error")
return render_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"))
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"))
else:
return render_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"))
return render_title_template('shelf_edit.html', shelf=shelf, title=_(u"Edit a shelf"))
@ -1413,7 +1412,7 @@ def show_shelf(shelf_id):
cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
result.append(cur_book)
return render_template('shelf.html', entries=result, title=_(u"Shelf: '%(name)s'", name=shelf.name), shelf=shelf)
return render_title_template('shelf.html', entries=result, title=_(u"Shelf: '%(name)s'", name=shelf.name), shelf=shelf)
@app.route("/shelf/order/<int:shelf_id>", methods=["GET", "POST"])
@ -1437,11 +1436,13 @@ def order_shelf(shelf_id):
ub.Shelf.id == shelf_id))).first()
result = list()
if shelf:
books_in_shelf2 = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by(ub.BookShelf.order.asc()).all()
books_in_shelf2 = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id)\
.order_by(ub.BookShelf.order.asc()).all()
for book in books_in_shelf2:
cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
result.append(cur_book)
return render_template('shelf_order.html', entries=result, title=_(u"Change order of Shelf: '%(name)s'", name=shelf.name), shelf=shelf)
return render_title_template('shelf_order.html', entries=result,
title=_(u"Change order of Shelf: '%(name)s'", name=shelf.name), shelf=shelf)
@app.route("/me", methods=["GET", "POST"])
@ -1502,11 +1503,11 @@ def profile():
except IntegrityError:
ub.session.rollback()
flash(_(u"Found an existing account for this email address."), category="error")
return render_template("user_edit.html", content=content, downloads=downloads,
return render_title_template("user_edit.html", content=content, downloads=downloads,
title=_(u"%(name)s's profile", name=current_user.nickname))
flash(_(u"Profile updated"), category="success")
return render_template("user_edit.html", translations=translations, profile=1, languages=languages, content=content,
downloads=downloads, title=_(u"%(name)s's profile", name=current_user.nickname))
return render_title_template("user_edit.html", translations=translations, profile=1, languages=languages, content=content,
downloads=downloads,title=_(u"%(name)s's profile", name=current_user.nickname))
@app.route("/admin/view")
@ -1515,33 +1516,42 @@ def profile():
def admin():
content = ub.session.query(ub.User).all()
settings = ub.session.query(ub.Settings).first()
return render_template("admin.html", content=content, email=settings, config=config, title=_(u"Admin page"))
return render_title_template("admin.html", content=content, email=settings, config=config, title=_(u"Admin page"))
@app.route("/admin/config")
@app.route("/admin/config", methods=["GET", "POST"])
@login_required
@admin_required
def configuration():
return render_template("config_edit.html", content=config, title=_(u"Basic Configuration"))
return configuration_helper()
@app.route("/config", methods=["GET", "POST"] )
@unconfigured
def basic_configuration():
return configuration_helper()
def configuration_helper():
global global_task
reboot_required= False
if request.method == "POST":
to_save = request.form.to_dict()
content = ub.session.query(ub.Settings).first()
content = ub.session.query(ub.Settings).first() # ToDo replace content with config ?
if "config_calibre_dir" in to_save:
content.config_calibre_dir = to_save["config_calibre_dir"]
if content.config_calibre_dir != to_save["config_calibre_dir"]:
content.config_calibre_dir = to_save["config_calibre_dir"]
reboot_required = True
if "config_port" in to_save:
content.config_port = to_save["config_port"]
if "config_calibre_web_title" in to_save:
content.config_calibre_web_title = to_save["config_calibre_web_title"]
if content.config_port != int(to_save["config_port"]):
content.config_port = int(to_save["config_port"])
reboot_required = True
if "config_calibre_web_title" in to_save:
content.config_calibre_web_title = to_save["config_calibre_web_title"]
if "config_title_regex" in to_save:
content.config_title_regex = to_save["config_title_regex"]
if content.config_title_regex != to_save["config_title_regex"]:
content.config_title_regex = to_save["config_title_regex"]
reboot_required = True
if "config_log_level" in to_save:
content.config_log_level = to_save["config_log_level"]
# ToDo check reboot required
if "config_random_books" in to_save:
content.config_random_books = int(to_save["config_random_books"])
if "config_books_per_page" in to_save:
@ -1561,16 +1571,19 @@ def basic_configuration():
config.loadSettings()
except e:
flash(e, category="error")
return render_template("config_edit.html", content=config, title=_(u"Basic Configuration"))
return render_title_template("config_edit.html", content=config, title=_(u"Basic Configuration"))
ub.session.close()
ub.engine.dispose()
# stop tornado server
server = IOLoop.instance()
server.add_callback(server.stop)
global_task = 0
return render_template("config_edit.html", content=config, title=_(u"Basic Configuration"))
if reboot_required:
if config.is_Calibre_Configured:
db.session.close()
# db.engine.dispose() # ToDo verify correct
ub.session.close()
ub.engine.dispose()
# stop tornado server
server = IOLoop.instance()
server.add_callback(server.stop)
global_task = 0
return render_title_template("config_edit.html", content=config, title=_(u"Basic Configuration"))
@app.route("/admin/user/new", methods=["GET", "POST"])
@ -1590,7 +1603,7 @@ def new_user():
to_save = request.form.to_dict()
if not to_save["nickname"] or not to_save["email"] or not to_save["password"]:
flash(_(u"Please fill out all fields!"), category="error")
return render_template("user_edit.html", new_user=1, content=content, title=_(u"Add new user"))
return render_title_template("user_edit.html", new_user=1, content=content, title=_(u"Add new user"))
content.password = generate_password_hash(to_save["password"])
content.nickname = to_save["nickname"]
content.email = to_save["email"]
@ -1629,7 +1642,7 @@ def new_user():
except IntegrityError:
ub.session.rollback()
flash(_(u"Found an existing account for this email address or nickname."), category="error")
return render_template("user_edit.html", new_user=1, content=content, translations=translations,
return render_title_template("user_edit.html", new_user=1, content=content, translations=translations,
languages=languages, title=_(u"Add new user"))
@ -1658,7 +1671,7 @@ def edit_mailsettings():
category="success")
else:
flash(_(u"There was an error sending the Test E-Mail: %(res)s", res=result), category="error")
return render_template("email_edit.html", content=content, title=_(u"Edit mail settings"))
return render_title_template("email_edit.html", content=content, title=_(u"Edit mail settings"))
@app.route("/admin/user/<int:user_id>", methods=["GET", "POST"])
@ -1745,7 +1758,7 @@ def edit_user(user_id):
except IntegrityError:
ub.session.rollback()
flash(_(u"An unknown error occured."), category="error")
return render_template("user_edit.html", translations=translations, languages=languages, new_user=0,
return render_title_template("user_edit.html", translations=translations, languages=languages, new_user=0,
content=content, downloads=downloads, title=_(u"Edit User %(nick)s", nick=content.nickname))
@ -1787,7 +1800,7 @@ def edit_book(book_id):
if to_save["cover_url"] and os.path.splitext(to_save["cover_url"])[1].lower() == ".jpg":
img = requests.get(to_save["cover_url"])
f = open(os.path.join(config.DB_ROOT, book.path, "cover.jpg"), "wb")
f = open(os.path.join(config.config_calibre_dir, book.path, "cover.jpg"), "wb")
f.write(img.content)
f.close()
@ -1950,9 +1963,9 @@ def edit_book(book_id):
if "detail_view" in to_save:
return redirect(url_for('show_book', id=book.id))
else:
return render_template('book_edit.html', book=book, authors=author_names, cc=cc)
return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc, title=_(u"edit metadata"))
else:
return render_template('book_edit.html', book=book, authors=author_names, cc=cc)
return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc, title=_(u"edit metadata"))
else:
flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error")
return redirect(url_for("index"))
@ -1962,7 +1975,7 @@ def edit_book(book_id):
@login_required_if_no_ano
@upload_required
def upload():
if not config.UPLOADING:
if not config.config_uploading:
abort(404)
# create the function for sorting...
db.session.connection().connection.connection.create_function("title_sort", 1, db.title_sort)
@ -1977,7 +1990,7 @@ def upload():
title_dir = helper.get_valid_filename(title.decode('utf-8'), False)
author_dir = helper.get_valid_filename(author.decode('utf-8'), False)
data_name = title_dir
filepath = config.DB_ROOT + os.sep + author_dir + os.sep + title_dir
filepath = config.config_calibre_dir + os.sep + author_dir + os.sep + title_dir
saved_filename = filepath + os.sep + data_name + meta.extension
if not os.path.exists(filepath):
@ -2025,6 +2038,6 @@ def upload():
author_names.append(author.name)
cc = db.session.query(db.Custom_Columns).filter(db.Custom_Columns.datatype.notin_(db.cc_exceptions)).all()
if current_user.role_edit() or current_user.role_admin():
return render_template('book_edit.html', book=db_book, authors=author_names, cc=cc)
return render_title_template('book_edit.html', book=db_book, authors=author_names, cc=cc, title=_(u"edit metadata"))
book_in_shelfs = []
return render_template('detail.html', entry=db_book, cc=cc, title=db_book.title, books_shelfs=book_in_shelfs)
return render_title_template('detail.html', entry=db_book, cc=cc,title=db_book.title, books_shelfs=book_in_shelfs, )