Finalize graphical setup for calibre-web

This commit is contained in:
OzzieIsaacs 2017-01-28 20:16:40 +01:00
parent 75c89c28e1
commit 2c615fdf05
11 changed files with 508 additions and 325 deletions

12
cps.py
View File

@ -3,22 +3,20 @@ import sys
import time import time
base_path = os.path.dirname(os.path.abspath(__file__)) base_path = os.path.dirname(os.path.abspath(__file__))
# Insert local directories into path # Insert local directories into path
sys.path.insert(0, os.path.join(base_path, 'vendor')) sys.path.insert(0, os.path.join(base_path, 'vendor'))
from cps import web from cps import web
# from cps import config
from tornado.wsgi import WSGIContainer from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop from tornado.ioloop import IOLoop
if __name__ == '__main__': if __name__ == '__main__':
'''if config.DEVELOPMENT: if web.ub.DEVELOPMENT:
web.app.run(host="0.0.0.0", port=web.config.config_port, debug=True) web.app.run(host="0.0.0.0", port=web.ub.config.config_port, debug=True)
else:''' else:
http_server = HTTPServer(WSGIContainer(web.app)) http_server = HTTPServer(WSGIContainer(web.app))
http_server.listen(web.config.config_port) http_server.listen(web.ub.config.config_port)
IOLoop.instance().start() IOLoop.instance().start()
if web.global_task == 0: if web.global_task == 0:
@ -26,4 +24,4 @@ if __name__ == '__main__':
os.execl(sys.executable, sys.executable, *sys.argv) os.execl(sys.executable, sys.executable, *sys.argv)
else: else:
print("Performing shutdown of Calibre-web") print("Performing shutdown of Calibre-web")
os._exit(0) sys.exit(0)

View File

@ -7,12 +7,21 @@ from sqlalchemy.orm import *
import os import os
import re import re
import ast import ast
from ub import Config from ub import config
import ub
session = None
cc_exceptions = None
cc_classes = None
cc_ids = None
books_custom_column_links = None
engine = None
# user defined sort function for calibre databases (Series, etc.) # user defined sort function for calibre databases (Series, etc.)
def title_sort(title): def title_sort(title):
# calibre sort stuff # calibre sort stuff
config=Config() # config=Config()
title_pat = re.compile(config.config_title_regex, re.IGNORECASE) title_pat = re.compile(config.config_title_regex, re.IGNORECASE)
match = title_pat.search(title) match = title_pat.search(title)
if match: if match:
@ -218,7 +227,8 @@ class Books(Base):
languages = relationship('Languages', secondary=books_languages_link, backref='books') languages = relationship('Languages', secondary=books_languages_link, backref='books')
identifiers = relationship('Identifiers', backref='books') identifiers = relationship('Identifiers', backref='books')
def __init__(self, title, sort, author_sort, timestamp, pubdate, series_index, last_modified, path, has_cover, authors, tags): def __init__(self, title, sort, author_sort, timestamp, pubdate, series_index, last_modified, path, has_cover,
authors, tags): # ToDO check Authors and tags necessary
self.title = title self.title = title
self.sort = sort self.sort = sort
self.author_sort = author_sort self.author_sort = author_sort
@ -253,19 +263,33 @@ class Custom_Columns(Base):
return display_dict return display_dict
def setup_db(config): def setup_db():
global session global session
global cc_exceptions global cc_exceptions
global cc_classes global cc_classes
global cc_ids global cc_ids
global books_custom_column_links global books_custom_column_links
global engine
if config.config_calibre_dir is None: if config.config_calibre_dir is None or config.config_calibre_dir == u'':
return return False
dbpath = os.path.join(config.config_calibre_dir, "metadata.db") dbpath = os.path.join(config.config_calibre_dir, "metadata.db")
engine = create_engine('sqlite:///{0}'.format(dbpath.encode('utf-8')), echo=False) engine = create_engine('sqlite:///{0}'.format(dbpath.encode('utf-8')), echo=False)
try:
conn = engine.connect() conn = engine.connect()
except:
content = ub.session.query(ub.Settings).first()
content.config_calibre_dir = None
content.db_configured = False
ub.session.commit()
config.loadSettings()
return False
content = ub.session.query(ub.Settings).first()
content.db_configured = True
ub.session.commit()
config.loadSettings()
conn.connection.create_function('title_sort', 1, title_sort) conn.connection.create_function('title_sort', 1, title_sort)
cc = conn.execute("SELECT id, datatype FROM custom_columns") cc = conn.execute("SELECT id, datatype FROM custom_columns")
@ -310,3 +334,4 @@ def setup_db(config):
Session = sessionmaker() Session = sessionmaker()
Session.configure(bind=engine) Session.configure(bind=engine)
session = Session() session = Session()
return True

View File

@ -3,7 +3,7 @@ from lxml import etree
import os import os
import uploader import uploader
# ToDo: Check usage of original_file_name
def get_fb2_info(tmp_file_path, original_file_name, original_file_extension): def get_fb2_info(tmp_file_path, original_file_name, original_file_extension):
ns = { ns = {

View File

@ -1,8 +1,8 @@
#!/usr/bin/env python #!/usr/bin/env python
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import db, ub import db
# import config import ub
from flask import current_app as app from flask import current_app as app
import logging import logging
import smtplib import smtplib
@ -34,7 +34,8 @@ def update_download(book_id, user_id):
def make_mobi(book_id, calibrepath): def make_mobi(book_id, calibrepath):
vendorpath = os.path.join(os.path.normpath(os.path.dirname(os.path.realpath(__file__)) + os.sep + "../vendor" + os.sep)) vendorpath = os.path.join(os.path.normpath(os.path.dirname(os.path.realpath(__file__)) +
os.sep + "../vendor" + os.sep))
if sys.platform == "win32": if sys.platform == "win32":
kindlegen = os.path.join(vendorpath, u"kindlegen.exe") kindlegen = os.path.join(vendorpath, u"kindlegen.exe")
else: else:
@ -81,6 +82,7 @@ def make_mobi(book_id,calibrepath):
class StderrLogger(object): class StderrLogger(object):
buffer = '' buffer = ''
def __init__(self): def __init__(self):
self.logger = logging.getLogger('cps.web') self.logger = logging.getLogger('cps.web')
@ -89,7 +91,8 @@ class StderrLogger(object):
self.logger.debug(self.buffer) self.logger.debug(self.buffer)
self.buffer = '' self.buffer = ''
else: else:
self.buffer=self.buffer+message self.buffer += message
def send_raw_email(kindle_mail, msg): def send_raw_email(kindle_mail, msg):
settings = ub.get_mail_settings() settings = ub.get_mail_settings()
@ -145,13 +148,6 @@ def send_test_mail(kindle_mail):
def send_mail(book_id, kindle_mail, calibrepath): def send_mail(book_id, kindle_mail, calibrepath):
"""Send email with attachments""" """Send email with attachments"""
is_mobi = False
is_azw = False
is_azw3 = False
is_epub = False
is_pdf = False
file_path = None
settings = ub.get_mail_settings()
# create MIME message # create MIME message
msg = MIMEMultipart() msg = MIMEMultipart()
msg['Subject'] = _(u'Send to Kindle') msg['Subject'] = _(u'Send to Kindle')
@ -207,8 +203,7 @@ def get_attachment(file_path):
return attachment return attachment
except IOError: except IOError:
traceback.print_exc() traceback.print_exc()
message = (_('The requested file could not be read. Maybe wrong '\ message = (_('The requested file could not be read. Maybe wrong permissions?')) # ToDo: What is this?
'permissions?'))
return None return None
@ -218,7 +213,7 @@ def get_valid_filename(value, replace_whitespace=True):
filename. Limits num characters to 128 max. filename. Limits num characters to 128 max.
""" """
value = value[:128] value = value[:128]
re_slugify = re.compile('[^\w\s-]', re.UNICODE) # re_slugify = re.compile('[^\w\s-]', re.UNICODE)
value = unicodedata.normalize('NFKD', value) value = unicodedata.normalize('NFKD', value)
re_slugify = re.compile('[^\w\s-]', re.UNICODE) re_slugify = re.compile('[^\w\s-]', re.UNICODE)
value = unicode(re_slugify.sub('', value).strip()) value = unicode(re_slugify.sub('', value).strip())

View File

@ -75,7 +75,7 @@
</table> </table>
<div class="btn btn-default"><a href="{{url_for('configuration')}}">{{_('Configuration')}}</a></div> <div class="btn btn-default"><a href="{{url_for('configuration')}}">{{_('Configuration')}}</a></div>
<h2>{{_('Administration')}}</h2> <h2>{{_('Administration')}}</h2>
{% if not config.DEVELOPMENT %} {% if not development %}
<div class="btn btn-default" data-toggle="modal" data-target="#RestartDialog">{{_('Restart Calibre-web')}}</a></div> <div class="btn btn-default" data-toggle="modal" data-target="#RestartDialog">{{_('Restart Calibre-web')}}</a></div>
<div class="btn btn-default" data-toggle="modal" data-target="#ShutdownDialog">{{_('Stop Calibre-web')}}</a></div> <div class="btn btn-default" data-toggle="modal" data-target="#ShutdownDialog">{{_('Stop Calibre-web')}}</a></div>
{% endif %} {% endif %}

View File

@ -9,7 +9,7 @@
</div> </div>
<div class="form-group"> <div class="form-group">
<label for="config_port">{{_('Server Port')}}</label> <label for="config_port">{{_('Server Port')}}</label>
<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> <input type="number" min="1" max="65535" class="form-control" name="config_port" id="config_port" value="{% if content.config_port != None %}{{ content.config_port }}{% endif %}" autocomplete="off" required>
</div> </div>
<div class="form-group"> <div class="form-group">
<label for="config_calibre_web_title">{{_('Title')}}</label> <label for="config_calibre_web_title">{{_('Title')}}</label>
@ -17,11 +17,11 @@
</div> </div>
<div class="form-group"> <div class="form-group">
<label for="config_books_per_page">{{_('Books per page')}}</label> <label for="config_books_per_page">{{_('Books per page')}}</label>
<input type="text" class="form-control" name="config_books_per_page" id="config_books_per_page" value="{% if content.config_books_per_page != None %}{{ content.config_books_per_page }}{% endif %}" autocomplete="off"> <input type="number" min="1" max="200" class="form-control" name="config_books_per_page" id="config_books_per_page" value="{% if content.config_books_per_page != None %}{{ content.config_books_per_page }}{% endif %}" autocomplete="off">
</div> </div>
<div class="form-group"> <div class="form-group">
<label for="config_random_books">{{_('No. of random books to show')}}</label> <label for="config_random_books">{{_('No. of random books to show')}}</label>
<input type="text" class="form-control" name="config_random_books" id="config_random_books" value="{% if content.config_random_books != None %}{{ content.config_random_books }}{% endif %}" autocomplete="off"> <input type="number" min="1" max="30" class="form-control" name="config_random_books" id="config_random_books" value="{% if content.config_random_books != None %}{{ content.config_random_books }}{% endif %}" autocomplete="off">
</div> </div>
<div class="form-group"> <div class="form-group">
@ -31,10 +31,10 @@
<div class="form-group"> <div class="form-group">
<label for="config_log_level">{{_('Log Level')}}</label> <label for="config_log_level">{{_('Log Level')}}</label>
<select name="config_log_level" id="config_log_level" class="form-control"> <select name="config_log_level" id="config_log_level" class="form-control">
<option value="DEBUG" {% if content.config_log_level == 'DEBUG' %}selected{% endif %}>DEBUG</option> <option value="10" {% if content.config_log_level == 10 %}selected{% endif %}>DEBUG</option>
<option value="INFO" {% if content.config_log_level == 'INFO' or content.config_log_level == None %}selected{% endif %}>INFO</option> <option value="20" {% if content.config_log_level == 20 or content.config_log_level == None %}selected{% endif %}>INFO</option>
<option value="WARNING" {% if content.config_log_level == 'WARNING' %}selected{% endif %}>WARNING</option> <option value="30" {% if content.config_log_level == 30 %}selected{% endif %}>WARNING</option>
<option value="ERROR" {% if content.config_log_level == 'ERROR' %}selected{% endif %}>ERROR</option> <option value="40" {% if content.config_log_level == 40 %}selected{% endif %}>ERROR</option>
</select> </select>
</div> </div>
<div class="form-group"> <div class="form-group">
@ -50,6 +50,12 @@
<label for="config_public_reg">{{_('Enable public registration')}}</label> <label for="config_public_reg">{{_('Enable public registration')}}</label>
</div> </div>
<button type="submit" class="btn btn-default">{{_('Submit')}}</button> <button type="submit" class="btn btn-default">{{_('Submit')}}</button>
{% if not origin %}
<a href="{{ url_for('admin') }}" class="btn btn-default">{{_('Back')}}</a>
{% endif %}
{% if success %}
<a href="{{ url_for('login') }}" class="btn btn-default">{{_('Login')}}</a>
{% endif %}
</form> </form>
</div> </div>
{% endblock %} {% endblock %}

View File

@ -1,6 +1,6 @@
{% extends "layout.html" %} {% extends "layout.html" %}
{% block body %} {% block body %}
{% if g.user.show_random_books() %} {% if g.user.show_detail_random() %}
<div class="discover"> <div class="discover">
<h2>{{_('Discover (Random Books)')}}</h2> <h2>{{_('Discover (Random Books)')}}</h2>
<div class="row"> <div class="row">

View File

@ -12,19 +12,19 @@
<tbody> <tbody>
<tr> <tr>
<th>Python</th> <th>Python</th>
<td>{{Versions['PythonVersion']}}</td> <td>{{versions['PythonVersion']}}</td>
</tr> </tr>
<tr> <tr>
<th>Kindlegen</th> <th>Kindlegen</th>
<td>{{Versions['KindlegenVersion']}}</td> <td>{{versions['KindlegenVersion']}}</td>
</tr> </tr>
<tr> <tr>
<th>ImageMagick</th> <th>ImageMagick</th>
<td>{{Versions['ImageVersion']}}</td> <td>{{versions['ImageVersion']}}</td>
</tr> </tr>
<tr> <tr>
<th>PyPDF2</th> <th>PyPDF2</th>
<td>{{Versions['PyPdfVersion']}}</td> <td>{{versions['PyPdfVersion']}}</td>
</tr> </tr>
</tbody> </tbody>
</table> </table>

View File

@ -41,25 +41,33 @@
</select> </select>
</div> </div>
<div class="form-group"> <div class="form-group">
<input type="checkbox" name="show_random" id="show_random" {% if content.random_books %}checked{% endif %}> <input type="checkbox" name="show_random" id="show_random" {% if content.show_random_books() %}checked{% endif %}>
<label for="show_random">{{_('Show random books')}}</label> <label for="show_random">{{_('Show random books')}}</label>
</div> </div>
<div class="form-group"> <div class="form-group">
<input type="checkbox" name="show_hot" id="show_hot" {% if content.hot_books %}checked{% endif %}> <input type="checkbox" name="show_hot" id="show_hot" {% if content.show_hot_books() %}checked{% endif %}>
<label for="show_hot">{{_('Show hot books')}}</label> <label for="show_hot">{{_('Show hot books')}}</label>
</div> </div>
<div class="form-group"> <div class="form-group">
<input type="checkbox" name="show_language" id="show_language" {% if content.language_books %}checked{% endif %}> <input type="checkbox" name="show_language" id="show_language" {% if content.show_language() %}checked{% endif %}>
<label for="show_language">{{_('Show language selection')}}</label> <label for="show_language">{{_('Show language selection')}}</label>
</div> </div>
<div class="form-group"> <div class="form-group">
<input type="checkbox" name="show_series" id="show_series" {% if content.series_books %}checked{% endif %}> <input type="checkbox" name="show_series" id="show_series" {% if content.show_series() %}checked{% endif %}>
<label for="show_series">{{_('Show series selection')}}</label> <label for="show_series">{{_('Show series selection')}}</label>
</div> </div>
<div class="form-group"> <div class="form-group">
<input type="checkbox" name="show_category" id="show_category" {% if content.category_books %}checked{% endif %}> <input type="checkbox" name="show_category" id="show_category" {% if content.show_category() %}checked{% endif %}>
<label for="show_category">{{_('Show category selection')}}</label> <label for="show_category">{{_('Show category selection')}}</label>
</div> </div>
<div class="form-group">
<input type="checkbox" name="show_author" id="show_author" {% if content.show_author() %}checked{% endif %}>
<label for="show_author">{{_('Show author selection')}}</label>
</div>
<div class="form-group">
<input type="checkbox" name="show_detail_random" id="show_detail_random" {% if content.show_detail_random() %}checked{% endif %}>
<label for="show_detail_random">{{_('Show random books in detail view')}}</label>
</div>
{% if g.user and g.user.role_admin() and not profile %} {% if g.user and g.user.role_admin() and not profile %}
{% if not content.role_anonymous() %} {% if not content.role_anonymous() %}

352
cps/ub.py
View File

@ -8,6 +8,7 @@ from sqlalchemy.orm import *
from flask_login import AnonymousUserMixin from flask_login import AnonymousUserMixin
import os import os
import traceback import traceback
import logging
from werkzeug.security import generate_password_hash from werkzeug.security import generate_password_hash
from flask_babel import gettext as _ from flask_babel import gettext as _
@ -22,10 +23,26 @@ ROLE_UPLOAD = 4
ROLE_EDIT = 8 ROLE_EDIT = 8
ROLE_PASSWD = 16 ROLE_PASSWD = 16
ROLE_ANONYMOUS = 32 ROLE_ANONYMOUS = 32
DETAIL_RANDOM = 1
SIDEBAR_LANGUAGE = 2
SIDEBAR_SERIES = 4
SIDEBAR_CATEGORY = 8
SIDEBAR_HOT = 16
SIDEBAR_RANDOM = 32
SIDEBAR_AUTHOR = 64
DEFAULT_PASS = "admin123" DEFAULT_PASS = "admin123"
class UserBase():
DEVELOPMENT = False
class UserBase:
@staticmethod
def is_authenticated(self): def is_authenticated(self):
return True return True
@ -78,24 +95,172 @@ class UserBase():
return self.default_language return self.default_language
def show_random_books(self): def show_random_books(self):
return self.random_books if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_RANDOM == SIDEBAR_RANDOM else False
else:
return False
def show_language(self): def show_language(self):
return self.language_books if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_LANGUAGE == SIDEBAR_LANGUAGE else False
else:
return False
def show_hot_books(self): def show_hot_books(self):
return self.hot_books if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_HOT == SIDEBAR_HOT else False
else:
return False
def show_series(self): def show_series(self):
return self.series_books if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_SERIES == SIDEBAR_SERIES else False
else:
return False
def show_category(self): def show_category(self):
return self.category_books if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_CATEGORY == SIDEBAR_CATEGORY else False
else:
return False
def show_author(self):
if self.sidebar_view is not None:
return True if self.sidebar_view & SIDEBAR_AUTHOR == SIDEBAR_AUTHOR else False
else:
return False
def show_detail_random(self):
if self.sidebar_view is not None:
return True if self.sidebar_view & DETAIL_RANDOM == DETAIL_RANDOM else False
else:
return False
def __repr__(self): def __repr__(self):
return '<User %r>' % self.nickname return '<User %r>' % self.nickname
class Config():
# Baseclass for Users in Calibre-web, settings which are depending on certain users are stored here. It is derived from
# User Base (all access methods are declared there)
class User(UserBase, Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
nickname = Column(String(64), unique=True)
email = Column(String(120), unique=True, default="")
role = Column(SmallInteger, default=ROLE_USER)
password = Column(String)
kindle_mail = Column(String(120), default="")
shelf = relationship('Shelf', backref='user', lazy='dynamic')
downloads = relationship('Downloads', backref='user', lazy='dynamic')
locale = Column(String(2), default="en")
sidebar_view = Column(Integer, default=1)
#language_books = Column(Integer, default=1)
#series_books = Column(Integer, default=1)
#category_books = Column(Integer, default=1)
#hot_books = Column(Integer, default=1)
default_language = Column(String(3), default="all")
# Class for anonymous user is derived from User base and complets overrides methods and properties for the
# anonymous user
class Anonymous(AnonymousUserMixin, UserBase):
def __init__(self):
self.loadSettings()
def loadSettings(self):
data = session.query(User).filter(User.role.op('&')(ROLE_ANONYMOUS) == ROLE_ANONYMOUS).first()
settings = session.query(Settings).first()
self.nickname = data.nickname
self.role = data.role
self.sidebar_view = data.sidebar_view
self.default_language = data.default_language
#self.language_books = data.language_books
#self.series_books = data.series_books
#self.category_books = data.category_books
#self.hot_books = data.hot_books
self.default_language = data.default_language
self.locale = data.locale
self.anon_browse = settings.config_anonbrowse
def role_admin(self):
return False
def is_active(self):
return False
def is_anonymous(self):
return self.anon_browse
# Baseclass representing Shelfs in calibre-web inapp.db
class Shelf(Base):
__tablename__ = 'shelf'
id = Column(Integer, primary_key=True)
name = Column(String)
is_public = Column(Integer, default=0)
user_id = Column(Integer, ForeignKey('user.id'))
def __repr__(self):
return '<Shelf %r>' % self.name
# Baseclass representing Relationship between books and Shelfs in Calibre-web in app.db (N:M)
class BookShelf(Base):
__tablename__ = 'book_shelf_link'
id = Column(Integer, primary_key=True)
book_id = Column(Integer)
order = Column(Integer)
shelf = Column(Integer, ForeignKey('shelf.id'))
def __repr__(self):
return '<Book %r>' % self.id
# Baseclass representing Downloads from calibre-web in app.db
class Downloads(Base):
__tablename__ = 'downloads'
id = Column(Integer, primary_key=True)
book_id = Column(Integer)
user_id = Column(Integer, ForeignKey('user.id'))
def __repr__(self):
return '<Download %r' % self.book_id
# Baseclass for representing settings in app.db with email server settings and Calibre database settings
# (application settings)
class Settings(Base):
__tablename__ = 'settings'
id = Column(Integer, primary_key=True)
mail_server = Column(String)
mail_port = Column(Integer, default=25)
mail_use_ssl = Column(SmallInteger, default=0)
mail_login = Column(String)
mail_password = Column(String)
mail_from = Column(String)
config_calibre_dir = Column(String)
config_port = Column(Integer, default=8083)
config_calibre_web_title = Column(String, default=u'Calibre-web')
config_books_per_page = Column(Integer, default=60)
config_random_books = Column(Integer, default=4)
config_title_regex = Column(String, default=u'^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+')
config_log_level = Column(SmallInteger, default=logging.INFO)
config_uploading = Column(SmallInteger, default=0)
config_anonbrowse = Column(SmallInteger, default=0)
config_public_reg = Column(SmallInteger, default=0)
def __repr__(self):
pass
# Class holds all application specific settings in calibre-web
class Config:
def __init__(self): def __init__(self):
self.config_main_dir = os.path.join(os.path.normpath(os.path.dirname( self.config_main_dir = os.path.join(os.path.normpath(os.path.dirname(
os.path.realpath(__file__)) + os.sep + ".." + os.sep)) os.path.realpath(__file__)) + os.sep + ".." + os.sep))
@ -114,7 +279,7 @@ class Config():
self.config_uploading = data.config_uploading self.config_uploading = data.config_uploading
self.config_anonbrowse = data.config_anonbrowse self.config_anonbrowse = data.config_anonbrowse
self.config_public_reg = data.config_public_reg 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): if self.config_calibre_dir is not None: # and (self.db_configured is None or self.db_configured is True):
self.db_configured = True self.db_configured = True
else: else:
self.db_configured = False self.db_configured = False
@ -123,143 +288,22 @@ class Config():
def get_main_dir(self): def get_main_dir(self):
return self.config_main_dir return self.config_main_dir
@property #def is_Calibre_Configured(self):
def is_Calibre_Configured(self): # return self.db_configured
return self.db_configured
class User(UserBase,Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
nickname = Column(String(64), unique=True)
email = Column(String(120), unique=True, default="")
role = Column(SmallInteger, default=ROLE_USER)
password = Column(String)
kindle_mail = Column(String(120), default="")
shelf = relationship('Shelf', backref='user', lazy='dynamic')
downloads = relationship('Downloads', backref='user', lazy='dynamic')
locale = Column(String(2), default="en")
random_books = Column(Integer, default=1)
language_books = Column(Integer, default=1)
series_books = Column(Integer, default=1)
category_books = Column(Integer, default=1)
hot_books = Column(Integer, default=1)
default_language = Column(String(3), default="all")
class Anonymous(AnonymousUserMixin,UserBase):
# anon_browse = None
def __init__(self):
self.loadSettings()
def loadSettings(self):
data=session.query(User).filter(User.role.op('&')(ROLE_ANONYMOUS) == ROLE_ANONYMOUS).first()
settings=session.query(Settings).first()
self.nickname = data.nickname
self.role = data.role
self.random_books = data.random_books
self.default_language = data.default_language
self.language_books = data.language_books
self.series_books = data.series_books
self.category_books = data.category_books
self.hot_books = data.hot_books
self.default_language = data.default_language
self.locale = data.locale
self.anon_browse = settings.config_anonbrowse
def role_admin(self):
return False
def is_active(self):
return False
def is_anonymous(self):
return self.anon_browse
class Shelf(Base):
__tablename__ = 'shelf'
id = Column(Integer, primary_key=True)
name = Column(String)
is_public = Column(Integer, default=0)
user_id = Column(Integer, ForeignKey('user.id'))
def __repr__(self):
return '<Shelf %r>' % self.name
class BookShelf(Base):
__tablename__ = 'book_shelf_link'
id = Column(Integer, primary_key=True)
book_id = Column(Integer)
order = Column(Integer)
shelf = Column(Integer, ForeignKey('shelf.id'))
def __repr__(self):
return '<Book %r>' % self.id
class Downloads(Base):
__tablename__ = 'downloads'
id = Column(Integer, primary_key=True)
book_id = Column(Integer)
user_id = Column(Integer, ForeignKey('user.id'))
def __repr__(self):
return '<Download %r' % self.book_id
class Settings(Base):
__tablename__ = 'settings'
id = Column(Integer, primary_key=True)
mail_server = Column(String)
mail_port = Column(Integer, default = 25)
mail_use_ssl = Column(SmallInteger, default = 0)
mail_login = Column(String)
mail_password = Column(String)
mail_from = Column(String)
config_calibre_dir = Column(String)
config_port = Column(Integer, default = 8083)
config_calibre_web_title = Column(String,default = u'Calibre-web')
config_books_per_page = Column(Integer, default = 60)
config_random_books = Column(Integer, default = 4)
config_title_regex = Column(String,default=u'^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+')
config_log_level = Column(String, default=u'INFO')
config_uploading = Column(SmallInteger, default = 0)
config_anonbrowse = Column(SmallInteger, default = 0)
config_public_reg = Column(SmallInteger, default = 0)
def __repr__(self):
#return '<Smtp %r>' % (self.mail_server)
pass
# Migrate database to current version, has to be updated after every database change. Currently migration from
# everywhere to curent should work. Migration is done by checking if relevant coloums are existing, and than adding
# rows with SQL commands
def migrate_Database(): def migrate_Database():
if session.query(User).filter(User.role.op('&')(ROLE_ANONYMOUS) == ROLE_ANONYMOUS).first() is None:
create_anonymous_user()
try: try:
session.query(exists().where(User.random_books)).scalar() session.query(exists().where(User.locale)).scalar()
session.commit() session.commit()
except exc.OperationalError: # Database is not compatible, some rows are missing except exc.OperationalError: # Database is not compatible, some rows are missing
conn = engine.connect() conn = engine.connect()
conn.execute("ALTER TABLE user ADD column random_books INTEGER DEFAULT 1")
conn.execute("ALTER TABLE user ADD column locale String(2) DEFAULT 'en'") conn.execute("ALTER TABLE user ADD column locale String(2) DEFAULT 'en'")
conn.execute("ALTER TABLE user ADD column default_language String(3) DEFAULT 'all'") conn.execute("ALTER TABLE user ADD column default_language String(3) DEFAULT 'all'")
session.commit() session.commit()
try:
session.query(exists().where(User.language_books)).scalar()
session.commit()
except exc.OperationalError: # Database is not compatible, some rows are missing
conn = engine.connect()
conn.execute("ALTER TABLE user ADD column language_books INTEGER DEFAULT 1")
conn.execute("ALTER TABLE user ADD column series_books INTEGER DEFAULT 1")
conn.execute("ALTER TABLE user ADD column category_books INTEGER DEFAULT 1")
conn.execute("ALTER TABLE user ADD column hot_books INTEGER DEFAULT 1")
session.commit()
try: try:
session.query(exists().where(Settings.config_calibre_dir)).scalar() session.query(exists().where(Settings.config_calibre_dir)).scalar()
session.commit() session.commit()
@ -270,12 +314,34 @@ def migrate_Database():
conn.execute("ALTER TABLE Settings ADD column `config_calibre_web_title` String DEFAULT 'Calibre-web'") conn.execute("ALTER TABLE Settings ADD column `config_calibre_web_title` String DEFAULT 'Calibre-web'")
conn.execute("ALTER TABLE Settings ADD column `config_books_per_page` INTEGER DEFAULT 60") conn.execute("ALTER TABLE Settings ADD column `config_books_per_page` INTEGER DEFAULT 60")
conn.execute("ALTER TABLE Settings ADD column `config_random_books` INTEGER DEFAULT 4") conn.execute("ALTER TABLE Settings ADD column `config_random_books` INTEGER DEFAULT 4")
conn.execute("ALTER TABLE Settings ADD column `config_title_regex` String DEFAULT '^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+'") conn.execute("ALTER TABLE Settings ADD column `config_title_regex` String DEFAULT "
conn.execute("ALTER TABLE Settings ADD column `config_log_level` String DEFAULT 'INFO'") "'^(A|The|An|Der|Die|Das|Den|Ein|Eine|Einen|Dem|Des|Einem|Eines)\s+'")
conn.execute("ALTER TABLE Settings ADD column `config_log_level` SmallInteger DEFAULT '" + logging.INFO + "'")
conn.execute("ALTER TABLE Settings ADD column `config_uploading` SmallInteger DEFAULT 0") conn.execute("ALTER TABLE Settings ADD column `config_uploading` SmallInteger DEFAULT 0")
conn.execute("ALTER TABLE Settings ADD column `config_anonbrowse` SmallInteger DEFAULT 0") conn.execute("ALTER TABLE Settings ADD column `config_anonbrowse` SmallInteger DEFAULT 0")
conn.execute("ALTER TABLE Settings ADD column `config_public_reg` SmallInteger DEFAULT 0") conn.execute("ALTER TABLE Settings ADD column `config_public_reg` SmallInteger DEFAULT 0")
session.commit() session.commit()
try:
create = False
session.query(exists().where(User.sidebar_view)).scalar()
session.commit()
except exc.OperationalError: # Database is not compatible, some rows are missing
conn = engine.connect()
conn.execute("ALTER TABLE user ADD column `sidebar_view` Integer DEFAULT 1")
session.commit()
create=True
try:
if create:
conn.execute("SELET language_books FROM user")
session.commit()
except exc.OperationalError:
conn = engine.connect()
conn.execute("UPDATE user SET 'sidebar_view' = (random_books*"+str(SIDEBAR_RANDOM)+"+ language_books *"+
str(SIDEBAR_LANGUAGE)+"+ series_books *"+str(SIDEBAR_SERIES)+"+ category_books *"+str(SIDEBAR_CATEGORY)+
"+ hot_books *"+str(SIDEBAR_HOT)+"+"+str(SIDEBAR_AUTHOR)+"+"+str(DETAIL_RANDOM)+")")
session.commit()
if session.query(User).filter(User.role.op('&')(ROLE_ANONYMOUS) == ROLE_ANONYMOUS).first() is None:
create_anonymous_user()
def create_default_config(): def create_default_config():
settings = Settings() settings = Settings()
@ -307,6 +373,8 @@ def get_mail_settings():
return data return data
# Generate user Guest (translated text), as anoymous user, no rights
def create_anonymous_user(): def create_anonymous_user():
user = User() user = User()
user.nickname = _("Guest") user.nickname = _("Guest")
@ -322,10 +390,14 @@ def create_anonymous_user():
pass pass
# Generate User admin with admin123 password, and access to everything
def create_admin_user(): def create_admin_user():
user = User() user = User()
user.nickname = "admin" user.nickname = "admin"
user.role = ROLE_USER + ROLE_ADMIN + ROLE_DOWNLOAD + ROLE_UPLOAD + ROLE_EDIT + ROLE_PASSWD user.role = ROLE_USER + ROLE_ADMIN + ROLE_DOWNLOAD + ROLE_UPLOAD + ROLE_EDIT + ROLE_PASSWD
user.sidebar_view = DETAIL_RANDOM + SIDEBAR_LANGUAGE + SIDEBAR_SERIES + SIDEBAR_CATEGORY + SIDEBAR_HOT + \
SIDEBAR_RANDOM + SIDEBAR_AUTHOR
user.password = generate_password_hash(DEFAULT_PASS) user.password = generate_password_hash(DEFAULT_PASS)
session.add(user) session.add(user)
@ -335,10 +407,13 @@ def create_admin_user():
session.rollback() session.rollback()
pass pass
# Open session for database connection
Session = sessionmaker() Session = sessionmaker()
Session.configure(bind=engine) Session.configure(bind=engine)
session = Session() session = Session()
# generate database and admin and guest user, if no database is existing
if not os.path.exists(dbpath): if not os.path.exists(dbpath):
try: try:
Base.metadata.create_all(engine) Base.metadata.create_all(engine)
@ -349,3 +424,6 @@ if not os.path.exists(dbpath):
pass pass
else: else:
migrate_Database() migrate_Database()
# Generate global Settings Object accecable from every file
config = Config()

View File

@ -1,13 +1,14 @@
#!/usr/bin/env python #!/usr/bin/env python
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import mimetypes import mimetypes
import logging import logging
from logging.handlers import RotatingFileHandler from logging.handlers import RotatingFileHandler
import textwrap import textwrap
from flask import Flask, render_template, session, request, Response, redirect, url_for, send_from_directory, \ from flask import Flask, render_template, session, request, Response, redirect, url_for, send_from_directory, \
make_response, g, flash, abort make_response, g, flash, abort
import ub, helper import ub
from ub import config
import helper
import os import os
import errno import errno
from sqlalchemy.sql.expression import func from sqlalchemy.sql.expression import func
@ -18,7 +19,8 @@ from flask_login import LoginManager, login_user, logout_user, login_required, c
from flask_principal import Principal, Identity, AnonymousIdentity, identity_changed from flask_principal import Principal, Identity, AnonymousIdentity, identity_changed
from flask_babel import Babel from flask_babel import Babel
from flask_babel import gettext as _ from flask_babel import gettext as _
import requests, zipfile import requests
import zipfile
from werkzeug.security import generate_password_hash, check_password_hash from werkzeug.security import generate_password_hash, check_password_hash
from babel import Locale as LC from babel import Locale as LC
from babel import negotiate_locale from babel import negotiate_locale
@ -40,16 +42,17 @@ from tornado.ioloop import IOLoop
try: try:
from wand.image import Image from wand.image import Image
use_generic_pdf_cover = False use_generic_pdf_cover = False
except ImportError, e: except ImportError, e:
use_generic_pdf_cover = True use_generic_pdf_cover = True
from cgi import escape from cgi import escape
########################################## Global variables ######################################################## # Global variables
global_task = None global_task = None
########################################## Proxy Helper class ###################################################### # Proxy Helper class
class ReverseProxied(object): class ReverseProxied(object):
"""Wrap the application in this middleware and configure the """Wrap the application in this middleware and configure the
front-end server to add these headers, to let you quietly bind front-end server to add these headers, to let you quietly bind
@ -68,8 +71,8 @@ class ReverseProxied(object):
} }
""" """
def __init__(self, app): def __init__(self, application):
self.app = app self.app = application
def __call__(self, environ, start_response): def __call__(self, environ, start_response):
script_name = environ.get('HTTP_X_SCRIPT_NAME', '') script_name = environ.get('HTTP_X_SCRIPT_NAME', '')
@ -87,7 +90,8 @@ class ReverseProxied(object):
environ['HTTP_HOST'] = server environ['HTTP_HOST'] = server
return self.app(environ, start_response) return self.app(environ, start_response)
########################################## Main code ##############################################################
# Main code
mimetypes.init() mimetypes.init()
mimetypes.add_type('application/xhtml+xml', '.xhtml') mimetypes.add_type('application/xhtml+xml', '.xhtml')
mimetypes.add_type('application/epub+zip', '.epub') mimetypes.add_type('application/epub+zip', '.epub')
@ -99,23 +103,19 @@ mimetypes.add_type('application/x-cbz', '.cbz')
mimetypes.add_type('application/x-cbt', '.cbt') mimetypes.add_type('application/x-cbt', '.cbt')
mimetypes.add_type('image/vnd.djvu', '.djvu') mimetypes.add_type('image/vnd.djvu', '.djvu')
app = (Flask(__name__)) app = (Flask(__name__))
app.wsgi_app = ReverseProxied(app.wsgi_app) app.wsgi_app = ReverseProxied(app.wsgi_app)
'''formatter = logging.Formatter( '''formatter = logging.Formatter(
"[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s") "[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s")
file_handler = RotatingFileHandler(os.path.join(config.LOG_DIR, "calibre-web.log"), maxBytes=50000, backupCount=1) file_handler = RotatingFileHandler(os.path.join(config.get_main_dir, "calibre-web.log"), maxBytes=50000, backupCount=1)
file_handler.setFormatter(formatter) file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler) app.logger.addHandler(file_handler)
if config.DEVELOPMENT: app.logger.setLevel(config.config_log_level)
app.logger.setLevel(logging.DEBUG)
else:
app.logger.setLevel(logging.INFO)
app.logger.info('Starting Calibre Web...') app.logger.info('Starting Calibre Web...')
logging.getLogger("book_formats").addHandler(file_handler) logging.getLogger("book_formats").addHandler(file_handler)
logging.getLogger("book_formats").setLevel(logging.INFO)''' logging.getLogger("book_formats").setLevel(config.config_log_level)'''
Principal(app) Principal(app)
@ -123,10 +123,6 @@ babel = Babel(app)
import uploader import uploader
# establish connection to calibre-db
config=ub.Config()
db.setup_db(config)
lm = LoginManager(app) lm = LoginManager(app)
lm.init_app(app) lm.init_app(app)
lm.login_view = 'login' lm.login_view = 'login'
@ -134,7 +130,7 @@ lm.anonymous_user = ub.Anonymous
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT' app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
db.setup_db()
@babel.localeselector @babel.localeselector
def get_locale(): def get_locale():
@ -155,14 +151,15 @@ def get_timezone():
@lm.user_loader @lm.user_loader
def load_user(id): def load_user(user_id):
return ub.session.query(ub.User).filter(ub.User.id == int(id)).first() return ub.session.query(ub.User).filter(ub.User.id == int(user_id)).first()
@lm.header_loader @lm.header_loader
def load_user_from_header(header_val): def load_user_from_header(header_val):
if header_val.startswith('Basic '): if header_val.startswith('Basic '):
header_val = header_val.replace('Basic ', '', 1) header_val = header_val.replace('Basic ', '', 1)
basic_username = basic_password = ''
try: try:
header_val = base64.b64decode(header_val) header_val = base64.b64decode(header_val)
basic_username = header_val.split(':')[0] basic_username = header_val.split(':')[0]
@ -239,11 +236,9 @@ class Pagination(object):
def iter_pages(self, left_edge=2, left_current=2, def iter_pages(self, left_edge=2, left_current=2,
right_current=5, right_edge=2): right_current=5, right_edge=2):
last = 0 last = 0
for num in xrange(1, self.pages + 1): for num in xrange(1, self.pages + 1): # ToDo: can be simplified
if num <= left_edge or \ if num <= left_edge or (num > self.page - left_current - 1 and num < self.page + right_current) \
(num > self.page - left_current - 1 and \ or num > self.pages - right_edge:
num < self.page + right_current) or \
num > self.pages - right_edge:
if last + 1 != num: if last + 1 != num:
yield None yield None
yield num yield num
@ -275,6 +270,7 @@ def shortentitle_filter(s):
s = textwrap.wrap(s, 60, break_long_words=False)[0] + ' [...]' s = textwrap.wrap(s, 60, break_long_words=False)[0] + ' [...]'
return s return s
@app.template_filter('mimetype') @app.template_filter('mimetype')
def mimetype_filter(val): def mimetype_filter(val):
try: try:
@ -288,22 +284,27 @@ def admin_required(f):
""" """
Checks if current_user.role == 1 Checks if current_user.role == 1
""" """
@wraps(f) @wraps(f)
def inner(*args, **kwargs): def inner(*args, **kwargs):
if current_user.role_admin(): if current_user.role_admin():
return f(*args, **kwargs) return f(*args, **kwargs)
abort(403) abort(403)
return inner return inner
def unconfigured(f): def unconfigured(f):
""" """
Checks if current_user.role == 1 Checks if current_user.role == 1
""" """
@wraps(f) @wraps(f)
def inner(*args, **kwargs): def inner(*args, **kwargs):
if config.is_Calibre_Configured: if not config.db_configured:
return f(*args, **kwargs) return f(*args, **kwargs)
abort(403) abort(403)
return inner return inner
@ -313,6 +314,7 @@ def download_required(f):
if current_user.role_download() or current_user.role_admin(): if current_user.role_download() or current_user.role_admin():
return f(*args, **kwargs) return f(*args, **kwargs)
abort(403) abort(403)
return inner return inner
@ -322,6 +324,7 @@ def upload_required(f):
if current_user.role_upload() or current_user.role_admin(): if current_user.role_upload() or current_user.role_admin():
return f(*args, **kwargs) return f(*args, **kwargs)
abort(403) abort(403)
return inner return inner
@ -331,6 +334,7 @@ def edit_required(f):
if current_user.role_edit() or current_user.role_admin(): if current_user.role_edit() or current_user.role_admin():
return f(*args, **kwargs) return f(*args, **kwargs)
abort(403) abort(403)
return inner return inner
@ -340,7 +344,7 @@ def fill_indexpage(page, database, db_filter, order):
filter = db.Books.languages.any(db.Languages.lang_code == current_user.filter_language()) filter = db.Books.languages.any(db.Languages.lang_code == current_user.filter_language())
else: else:
filter = True filter = True
if current_user.show_random_books(): if current_user.show_detail_random():
random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.config_random_books) random = db.session.query(db.Books).filter(filter).order_by(func.random()).limit(config.config_random_books)
else: else:
random = false random = false
@ -405,19 +409,23 @@ def modify_database_object(input_elements, db_book_object, db_object, db_session
# add element to book # add element to book
db_book_object.append(new_element) db_book_object.append(new_element)
def render_title_template(*args, **kwargs): def render_title_template(*args, **kwargs):
return render_template(instance=config.config_calibre_web_title, *args, **kwargs) return render_template(instance=config.config_calibre_web_title, *args, **kwargs)
@app.before_request @app.before_request
def before_request(): def before_request():
if ub.DEVELOPMENT:
reload(ub)
g.user = current_user g.user = current_user
g.public_shelfes = ub.session.query(ub.Shelf).filter(ub.Shelf.is_public == 1).all()
g.allow_registration = config.config_public_reg g.allow_registration = config.config_public_reg
g.allow_upload = config.config_uploading g.allow_upload = config.config_uploading
if not config.db_configured and request.endpoint not in ('basic_configuration', 'login') and '/static/' not in request.path:
return redirect(url_for('basic_configuration'))
########################################## Routing functions #######################################################
# Routing functions
@app.route("/opds") @app.route("/opds")
@requires_basic_auth_if_no_ano @requires_basic_auth_if_no_ano
@ -440,6 +448,7 @@ def feed_osd():
response.headers["Content-Type"] = "application/xml" response.headers["Content-Type"] = "application/xml"
return response return response
@app.route("/opds/search/<query>") @app.route("/opds/search/<query>")
@requires_basic_auth_if_no_ano @requires_basic_auth_if_no_ano
def feed_cc_search(query): def feed_cc_search(query):
@ -522,7 +531,8 @@ def feed_hot():
entries = db.session.query(db.Books).filter(filter).filter(db.Books.ratings.any(db.Ratings.rating > 9)).offset( entries = db.session.query(db.Books).filter(filter).filter(db.Books.ratings.any(db.Ratings.rating > 9)).offset(
off).limit(config.config_books_per_page) off).limit(config.config_books_per_page)
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page, pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
len(db.session.query(db.Books).filter(filter).filter(db.Books.ratings.any(db.Ratings.rating > 9)).all())) len(db.session.query(db.Books).filter(filter).filter(
db.Books.ratings.any(db.Ratings.rating > 9)).all()))
xml = render_template('feed.xml', entries=entries, pagination=pagination) xml = render_template('feed.xml', entries=entries, pagination=pagination)
response = make_response(xml) response = make_response(xml)
response.headers["Content-Type"] = "application/xml" response.headers["Content-Type"] = "application/xml"
@ -562,7 +572,8 @@ def feed_author(id):
entries = db.session.query(db.Books).filter(db.Books.authors.any(db.Authors.id == id)).filter( entries = db.session.query(db.Books).filter(db.Books.authors.any(db.Authors.id == id)).filter(
filter).offset(off).limit(config.config_books_per_page) filter).offset(off).limit(config.config_books_per_page)
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page, pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
len(db.session.query(db.Books).filter(db.Books.authors.any(db.Authors.id == id )).filter(filter).all())) len(db.session.query(db.Books).filter(db.Books.authors.any(db.Authors.id == id)).filter(
filter).all()))
xml = render_template('feed.xml', entries=entries, pagination=pagination) xml = render_template('feed.xml', entries=entries, pagination=pagination)
response = make_response(xml) response = make_response(xml)
response.headers["Content-Type"] = "application/xml" response.headers["Content-Type"] = "application/xml"
@ -597,7 +608,8 @@ def feed_category(id):
entries = db.session.query(db.Books).filter(db.Books.tags.any(db.Tags.id == id)).order_by( entries = db.session.query(db.Books).filter(db.Books.tags.any(db.Tags.id == id)).order_by(
db.Books.timestamp.desc()).filter(filter).offset(off).limit(config.config_books_per_page) db.Books.timestamp.desc()).filter(filter).offset(off).limit(config.config_books_per_page)
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page, pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
len(db.session.query(db.Books).filter(db.Books.tags.any(db.Tags.id==id)).filter(filter).all())) len(db.session.query(db.Books).filter(db.Books.tags.any(db.Tags.id == id)).filter(
filter).all()))
xml = render_template('feed.xml', entries=entries, pagination=pagination) xml = render_template('feed.xml', entries=entries, pagination=pagination)
response = make_response(xml) response = make_response(xml)
response.headers["Content-Type"] = "application/xml" response.headers["Content-Type"] = "application/xml"
@ -636,7 +648,8 @@ def feed_series(id):
entries = db.session.query(db.Books).filter(db.Books.series.any(db.Series.id == id)).order_by( entries = db.session.query(db.Books).filter(db.Books.series.any(db.Series.id == id)).order_by(
db.Books.timestamp.desc()).filter(filter).offset(off).limit(config.config_books_per_page) db.Books.timestamp.desc()).filter(filter).offset(off).limit(config.config_books_per_page)
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page, pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
len(db.session.query(db.Books).filter(db.Books.series.any(db.Series.id == id)).filter(filter).all())) len(db.session.query(db.Books).filter(db.Books.series.any(db.Series.id == id)).filter(
filter).all()))
xml = render_template('feed.xml', entries=entries, pagination=pagination) xml = render_template('feed.xml', entries=entries, pagination=pagination)
response = make_response(xml) response = make_response(xml)
response.headers["Content-Type"] = "application/xml" response.headers["Content-Type"] = "application/xml"
@ -661,6 +674,7 @@ def get_opds_download_link(book_id, format):
response.headers["Content-Disposition"] = "attachment; filename=\"%s.%s\"" % (data.name, format) response.headers["Content-Disposition"] = "attachment; filename=\"%s.%s\"" % (data.name, format)
return response return response
@app.route("/ajax/book/<string:uuid>") @app.route("/ajax/book/<string:uuid>")
@requires_basic_auth_if_no_ano @requires_basic_auth_if_no_ano
def get_metadata_calibre_companion(uuid): def get_metadata_calibre_companion(uuid):
@ -673,6 +687,7 @@ def get_metadata_calibre_companion(uuid):
else: else:
return "" return ""
@app.route("/get_authors_json", methods=['GET', 'POST']) @app.route("/get_authors_json", methods=['GET', 'POST'])
@login_required_if_no_ano @login_required_if_no_ano
def get_authors_json(): def get_authors_json():
@ -752,8 +767,8 @@ def get_matching_tags():
@app.route('/page/<int:page>') @app.route('/page/<int:page>')
@login_required_if_no_ano @login_required_if_no_ano
def index(page): def index(page):
if config.is_Calibre_Configured == False: #if not config.db_configured:
return redirect(url_for('basic_configuration')) # return redirect(url_for('basic_configuration'))
entries, random, pagination = fill_indexpage(page, db.Books, True, db.Books.timestamp.desc()) entries, random, pagination = fill_indexpage(page, db.Books, True, db.Books.timestamp.desc())
return render_title_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")) title=_(u"Latest Books"))
@ -788,8 +803,9 @@ def hot_books(page):
@app.route('/discover/page/<int:page>') @app.route('/discover/page/<int:page>')
@login_required_if_no_ano @login_required_if_no_ano
def discover(page): def discover(page):
entries, random, pagination = fill_indexpage(page, db.Books, func.randomblob(2), db.Books.timestamp.desc()) entries, random, pagination = fill_indexpage(page, db.Books, True, func.randomblob(2))
return render_title_template('discover.html', entries=entries, pagination=pagination, instance=config.config_calibre_web_title, title=_(u"Random Books")) pagination = Pagination(1, config.config_books_per_page,config.config_books_per_page)
return render_title_template('discover.html', entries=entries, pagination=pagination, title=_(u"Random Books"))
@app.route("/author") @app.route("/author")
@ -949,7 +965,6 @@ def show_book(id):
@app.route("/admin") @app.route("/admin")
@login_required @login_required
def admin_forbidden(): def admin_forbidden():
return "Admin ONLY!"
abort(403) abort(403)
@ -958,21 +973,22 @@ def admin_forbidden():
def stats(): def stats():
counter = len(db.session.query(db.Books).all()) counter = len(db.session.query(db.Books).all())
authors = len(db.session.query(db.Authors).all()) authors = len(db.session.query(db.Authors).all())
Versions=uploader.book_formats.get_versions() versions = uploader.book_formats.get_versions()
vendorpath = os.path.join(config.get_main_dir + "vendor" + os.sep) vendorpath = os.path.join(config.get_main_dir + "vendor" + os.sep)
if sys.platform == "win32": if sys.platform == "win32":
kindlegen = os.path.join(vendorpath, u"kindlegen.exe") kindlegen = os.path.join(vendorpath, u"kindlegen.exe")
else: else:
kindlegen = os.path.join(vendorpath, u"kindlegen") kindlegen = os.path.join(vendorpath, u"kindlegen")
kindlegen_version=_('not installed') versions['KindlegenVersion'] = _('not installed')
if os.path.exists(kindlegen): if os.path.exists(kindlegen):
p = subprocess.Popen(kindlegen, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) p = subprocess.Popen(kindlegen, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
check = p.wait() stdin=subprocess.PIPE)
p.wait()
for lines in p.stdout.readlines(): for lines in p.stdout.readlines():
if re.search('Amazon kindlegen\(', lines): if re.search('Amazon kindlegen\(', lines):
Versions['KindlegenVersion'] = lines versions['KindlegenVersion'] = lines
Versions['PythonVersion']=sys.version versions['PythonVersion'] = sys.version
return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, Versions=Versions, return render_title_template('stats.html', bookcounter=counter, authorcounter=authors, versions=versions,
title=_(u"Statistics")) title=_(u"Statistics"))
@ -992,14 +1008,16 @@ def shutdown():
# stop tornado server # stop tornado server
server = IOLoop.instance() server = IOLoop.instance()
server.add_callback(server.stop) server.add_callback(server.stop)
showtext = {}
if task == 0: if task == 0:
text['text']=_(u'Performing Restart, please reload page') showtext['text'] = _(u'Performing Restart, please reload page')
else: else:
text['text']= _(u'Performing shutdown of server, please close window') showtext['text'] = _(u'Performing shutdown of server, please close window')
return json.dumps(text) return json.dumps(showtext)
else: else:
abort(404) abort(404)
@app.route("/search", methods=["GET"]) @app.route("/search", methods=["GET"])
@login_required_if_no_ano @login_required_if_no_ano
def search(): def search():
@ -1091,6 +1109,7 @@ def advanced_search():
def get_cover(cover_path): def get_cover(cover_path):
return send_from_directory(os.path.join(config.config_calibre_dir, 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/thumb_240_240/<path:book_id>")
@app.route("/opds/cover_240_240/<path:book_id>") @app.route("/opds/cover_240_240/<path:book_id>")
@app.route("/opds/cover_90_90/<path:book_id>") @app.route("/opds/cover_90_90/<path:book_id>")
@ -1169,14 +1188,16 @@ def get_download_link(book_id, format):
book = db.session.query(db.Books).filter(db.Books.id == book_id).first() book = db.session.query(db.Books).filter(db.Books.id == book_id).first()
data = db.session.query(db.Data).filter(db.Data.book == book.id).filter(db.Data.format == format.upper()).first() data = db.session.query(db.Data).filter(db.Data.book == book.id).filter(db.Data.format == format.upper()).first()
if data: if data:
if current_user.is_authenticated: # collect downloaded books only for registered user and not for anonymous user # collect downloaded books only for registered user and not for anonymous user
if current_user.is_authenticated:
helper.update_download(book_id, int(current_user.id)) helper.update_download(book_id, int(current_user.id))
author = helper.get_normalized_author(book.author_sort) author = helper.get_normalized_author(book.author_sort)
file_name = book.title file_name = book.title
if len(author) > 0: if len(author) > 0:
file_name = author + '-' + file_name file_name = author + '-' + file_name
file_name = helper.get_valid_filename(file_name) file_name = helper.get_valid_filename(file_name)
response = make_response(send_from_directory(os.path.join(config.config_calibre_dir, book.path), data.name + "." + format)) response = make_response(
send_from_directory(os.path.join(config.config_calibre_dir, book.path), data.name + "." + format))
try: try:
response.headers["Content-Type"] = mimetypes.types_map['.' + format] response.headers["Content-Type"] = mimetypes.types_map['.' + format]
except: except:
@ -1192,9 +1213,9 @@ def get_download_link(book_id, format):
else: else:
abort(404) abort(404)
@app.route('/register', methods=['GET', 'POST']) @app.route('/register', methods=['GET', 'POST'])
def register(): def register():
error = None
if not config.config_public_reg: if not config.config_public_reg:
abort(404) abort(404)
if current_user is not None and current_user.is_authenticated: if current_user is not None and current_user.is_authenticated:
@ -1232,8 +1253,7 @@ def register():
@app.route('/login', methods=['GET', 'POST']) @app.route('/login', methods=['GET', 'POST'])
def login(): def login():
error = None if not config.db_configured:
if config.is_Calibre_Configured == False:
return redirect(url_for('basic_configuration')) return redirect(url_for('basic_configuration'))
if current_user is not None and current_user.is_authenticated: if current_user is not None and current_user.is_authenticated:
return redirect(url_for('index')) return redirect(url_for('index'))
@ -1287,11 +1307,11 @@ def add_to_shelf(shelf_id, book_id):
if not shelf.is_public and not shelf.user_id == int(current_user.id): if not shelf.is_public and not shelf.user_id == int(current_user.id):
flash("Sorry you are not allowed to add a book to the the shelf: %s" % shelf.name) flash("Sorry you are not allowed to add a book to the the shelf: %s" % shelf.name)
return redirect(url_for('index')) return redirect(url_for('index'))
maxO = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first() maxOrder = ub.session.query(func.max(ub.BookShelf.order)).filter(ub.BookShelf.shelf == shelf_id).first()
if maxO[0] is None: if maxOrder[0] is None:
maxOrder = 0 maxOrder = 0
else: else:
maxOrder = maxO[0] maxOrder = maxOrder[0]
ins = ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1) ins = ub.BookShelf(shelf=shelf.id, book_id=book_id, order=maxOrder + 1)
ub.session.add(ins) ub.session.add(ins)
ub.session.commit() ub.session.commit()
@ -1332,7 +1352,8 @@ def create_shelf():
shelf.is_public = 1 shelf.is_public = 1
shelf.name = to_save["title"] shelf.name = to_save["title"]
shelf.user_id = int(current_user.id) shelf.user_id = int(current_user.id)
existing_shelf = ub.session.query(ub.Shelf).filter(or_((ub.Shelf.name == to_save["title"])&( ub.Shelf.is_public == 1), 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() (ub.Shelf.name == to_save["title"]) & (ub.Shelf.user_id == int(current_user.id)))).first()
if existing_shelf: 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")
@ -1347,14 +1368,17 @@ def create_shelf():
else: else:
return render_title_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"]) @app.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 = ub.session.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()
existing_shelf = ub.session.query(ub.Shelf).filter(or_((ub.Shelf.name == to_save["title"])&( ub.Shelf.is_public == 1), existing_shelf = ub.session.query(ub.Shelf).filter(
(ub.Shelf.name == to_save["title"])& (ub.Shelf.user_id == int(current_user.id)))).filter(ub.Shelf.id!=shelf_id).first() 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)))).filter(
ub.Shelf.id != shelf_id).first()
if existing_shelf: 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: else:
@ -1373,15 +1397,12 @@ def edit_shelf(shelf_id):
return render_title_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"))
@app.route("/shelf/delete/<int:shelf_id>") @app.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 = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).first()
deleted = 0
if current_user.role == ub.ROLE_ADMIN: if current_user.role == ub.ROLE_ADMIN:
deleted = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).delete() deleted = ub.session.query(ub.Shelf).filter(ub.Shelf.id == shelf_id).delete()
else: else:
deleted = ub.session.query(ub.Shelf).filter(ub.or_(ub.and_(ub.Shelf.user_id == int(current_user.id), deleted = ub.session.query(ub.Shelf).filter(ub.or_(ub.and_(ub.Shelf.user_id == int(current_user.id),
ub.Shelf.id == shelf_id), ub.Shelf.id == shelf_id),
@ -1407,12 +1428,14 @@ def show_shelf(shelf_id):
ub.Shelf.id == shelf_id))).first() ub.Shelf.id == shelf_id))).first()
result = list() result = list()
if shelf: if shelf:
books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by(ub.BookShelf.order.asc()).all() books_in_shelf = ub.session.query(ub.BookShelf).filter(ub.BookShelf.shelf == shelf_id).order_by(
ub.BookShelf.order.asc()).all()
for book in books_in_shelf: for book in books_in_shelf:
cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first() cur_book = db.session.query(db.Books).filter(db.Books.id == book.book_id).first()
result.append(cur_book) result.append(cur_book)
return render_title_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"]) @app.route("/shelf/order/<int:shelf_id>", methods=["GET", "POST"])
@ -1481,21 +1504,21 @@ def profile():
content.default_language = to_save["default_language"] content.default_language = to_save["default_language"]
if to_save["locale"]: if to_save["locale"]:
content.locale = to_save["locale"] content.locale = to_save["locale"]
content.random_books = 0 content.sidebar_view = 0
content.language_books = 0 if "show_random" in to_save:
content.series_books = 0 content.sidebar_view += ub.SIDEBAR_RANDOM
content.category_books = 0 if "show_language" in to_save:
content.hot_books = 0 content.sidebar_view += ub.SIDEBAR_LANGUAGE
if "show_random" in to_save and to_save["show_random"] == "on": if "show_series" in to_save:
content.random_books = 1 content.sidebar_view += ub.SIDEBAR_SERIES
if "show_language" in to_save and to_save["show_language"] == "on": if "show_category" in to_save:
content.language_books = 1 content.sidebar_view += ub.SIDEBAR_CATEGORY
if "show_series" in to_save and to_save["show_series"] == "on": if "show_hot" in to_save:
content.series_books = 1 content.sidebar_view += ub.SIDEBAR_HOT
if "show_category" in to_save and to_save["show_category"] == "on": if "show_author" in to_save:
content.category_books = 1 content.sidebar_view += ub.SIDEBAR_AUTHOR
if "show_hot" in to_save and to_save["show_hot"] == "on": if "show_detail_random" in to_save:
content.hot_books = 1 content.sidebar_view += ub.DETAIL_RANDOM
if "default_language" in to_save: if "default_language" in to_save:
content.default_language = to_save["default_language"] content.default_language = to_save["default_language"]
try: try:
@ -1506,7 +1529,8 @@ def profile():
return render_title_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)) title=_(u"%(name)s's profile", name=current_user.nickname))
flash(_(u"Profile updated"), category="success") flash(_(u"Profile updated"), category="success")
return render_title_template("user_edit.html", translations=translations, profile=1, languages=languages, content=content, 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)) downloads=downloads, title=_(u"%(name)s's profile", name=current_user.nickname))
@ -1516,29 +1540,36 @@ def profile():
def admin(): def admin():
content = ub.session.query(ub.User).all() content = ub.session.query(ub.User).all()
settings = ub.session.query(ub.Settings).first() settings = ub.session.query(ub.Settings).first()
return render_title_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,
development=ub.DEVELOPMENT, title=_(u"Admin page"))
@app.route("/admin/config", methods=["GET", "POST"]) @app.route("/admin/config", methods=["GET", "POST"])
@login_required @login_required
@admin_required @admin_required
def configuration(): def configuration():
return configuration_helper() return configuration_helper(0)
@app.route("/config", methods=["GET", "POST"]) @app.route("/config", methods=["GET", "POST"])
@unconfigured @unconfigured
def basic_configuration(): def basic_configuration():
return configuration_helper() return configuration_helper(1)
def configuration_helper():
def configuration_helper(origin):
global global_task global global_task
reboot_required = False reboot_required = False
db_change = False
success = False
if request.method == "POST": if request.method == "POST":
to_save = request.form.to_dict() to_save = request.form.to_dict()
content = ub.session.query(ub.Settings).first() # ToDo replace content with config ? content = ub.session.query(ub.Settings).first()
# ToDo: check lib vaild, and change without restart
if "config_calibre_dir" in to_save: if "config_calibre_dir" in to_save:
if 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"] content.config_calibre_dir = to_save["config_calibre_dir"]
reboot_required = True db_change = True
if "config_port" in to_save: if "config_port" in to_save:
if content.config_port != int(to_save["config_port"]): if content.config_port != int(to_save["config_port"]):
content.config_port = int(to_save["config_port"]) content.config_port = int(to_save["config_port"])
@ -1550,8 +1581,7 @@ def configuration_helper():
content.config_title_regex = to_save["config_title_regex"] content.config_title_regex = to_save["config_title_regex"]
reboot_required = True reboot_required = True
if "config_log_level" in to_save: if "config_log_level" in to_save:
content.config_log_level = to_save["config_log_level"] content.config_log_level = int(to_save["config_log_level"])
# ToDo check reboot required
if "config_random_books" in to_save: if "config_random_books" in to_save:
content.config_random_books = int(to_save["config_random_books"]) content.config_random_books = int(to_save["config_random_books"])
if "config_books_per_page" in to_save: if "config_books_per_page" in to_save:
@ -1566,16 +1596,26 @@ def configuration_helper():
if "config_public_reg" in to_save and to_save["config_public_reg"] == "on": if "config_public_reg" in to_save and to_save["config_public_reg"] == "on":
content.config_public_reg = 1 content.config_public_reg = 1
try: try:
if db_change:
if config.db_configured:
db.session.close()
db.engine.dispose()
ub.session.commit() ub.session.commit()
flash(_(u"Calibre-web configuration updated"), category="success") flash(_(u"Calibre-web configuration updated"), category="success")
config.loadSettings() config.loadSettings()
app.logger.setLevel(config.config_log_level)
logging.getLogger("book_formats").setLevel(config.config_log_level)
except e: except e:
flash(e, category="error") flash(e, category="error")
return render_title_template("config_edit.html", content=config, title=_(u"Basic Configuration")) return render_title_template("config_edit.html", content=config, origin=origin,
title=_(u"Basic Configuration"))
if db_change:
reload(db)
if not db.setup_db():
flash(_(u'DB location is not valid, please enter correct path'), category="error")
return render_title_template("config_edit.html", content=config, origin=origin,
title=_(u"Basic Configuration"))
if reboot_required: if reboot_required:
if config.is_Calibre_Configured:
db.session.close()
# db.engine.dispose() # ToDo verify correct # db.engine.dispose() # ToDo verify correct
ub.session.close() ub.session.close()
ub.engine.dispose() ub.engine.dispose()
@ -1583,7 +1623,11 @@ def configuration_helper():
server = IOLoop.instance() server = IOLoop.instance()
server.add_callback(server.stop) server.add_callback(server.stop)
global_task = 0 global_task = 0
return render_title_template("config_edit.html", content=config, title=_(u"Basic Configuration")) app.logger.info('Reboot required, restarting')
if origin:
success = True
return render_title_template("config_edit.html", origin=origin, success=success, content=config,
title=_(u"Basic Configuration"))
@app.route("/admin/user/new", methods=["GET", "POST"]) @app.route("/admin/user/new", methods=["GET", "POST"])
@ -1603,26 +1647,29 @@ def new_user():
to_save = request.form.to_dict() to_save = request.form.to_dict()
if not to_save["nickname"] or not to_save["email"] or not to_save["password"]: if not to_save["nickname"] or not to_save["email"] or not to_save["password"]:
flash(_(u"Please fill out all fields!"), category="error") flash(_(u"Please fill out all fields!"), category="error")
return render_title_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, translations=translations,
title=_(u"Add new user"))
content.password = generate_password_hash(to_save["password"]) content.password = generate_password_hash(to_save["password"])
content.nickname = to_save["nickname"] content.nickname = to_save["nickname"]
content.email = to_save["email"] content.email = to_save["email"]
content.default_language = to_save["default_language"] content.default_language = to_save["default_language"]
if "locale" in to_save: if "locale" in to_save:
content.locale = to_save["locale"] content.locale = to_save["locale"]
content.random_books = 0 content.sidebar_view = 0
content.language_books = 0 if "show_random" in to_save:
content.series_books = 0 content.sidebar_view += ub.SIDEBAR_RANDOM
content.category_books = 0
content.hot_books = 0
if "show_language" in to_save: if "show_language" in to_save:
content.language_books = to_save["show_language"] content.sidebar_view += ub.SIDEBAR_LANGUAGE
if "show_series" in to_save: if "show_series" in to_save:
content.series_books = to_save["show_series"] content.sidebar_view += ub.SIDEBAR_SERIES
if "show_category" in to_save: if "show_category" in to_save:
content.category_books = to_save["show_category"] content.sidebar_view += ub.SIDEBAR_CATEGORY
if "show_hot" in to_save: if "show_hot" in to_save:
content.hot_books = to_save["show_hot"] content.sidebar_view += ub.SIDEBAR_HOT
if "show_author" in to_save:
content.sidebar_view += ub.SIDEBAR_AUTHOR
if "show_detail_random" in to_save:
content.sidebar_view += ub.DETAIL_RANDOM
content.role = 0 content.role = 0
if "admin_role" in to_save: if "admin_role" in to_save:
content.role = content.role + ub.ROLE_ADMIN content.role = content.role + ub.ROLE_ADMIN
@ -1729,21 +1776,42 @@ def edit_user(user_id):
content.role = content.role + ub.ROLE_PASSWD content.role = content.role + ub.ROLE_PASSWD
elif "passwd_role" not in to_save and content.role_passwd(): elif "passwd_role" not in to_save and content.role_passwd():
content.role = content.role - ub.ROLE_PASSWD content.role = content.role - ub.ROLE_PASSWD
content.random_books = 0
content.language_books = 0 if "show_random" in to_save and not content.show_random_books():
content.series_books = 0 content.sidebar_view += ub.SIDEBAR_RANDOM
content.category_books = 0 elif "show_random" not in to_save and content.show_random_books():
content.hot_books = 0 content.sidebar_view -= ub.SIDEBAR_RANDOM
if "show_random" in to_save and to_save["show_random"] == "on":
content.random_books = 1 if "show_language" in to_save and not content.show_language():
if "show_language" in to_save and to_save["show_language"] == "on": content.sidebar_view += ub.SIDEBAR_LANGUAGE
content.language_books = 1 elif "show_language" not in to_save and content.show_language():
if "show_series" in to_save and to_save["show_series"] == "on": content.sidebar_view -= ub.SIDEBAR_LANGUAGE
content.series_books = 1
if "show_category" in to_save and to_save["show_category"] == "on": if "show_series" in to_save and not content.show_series():
content.category_books = 1 content.sidebar_view += ub.SIDEBAR_SERIES
if "show_hot" in to_save and to_save["show_hot"] == "on": elif "show_series" not in to_save and content.show_series():
content.hot_books = 1 content.sidebar_view -= ub.SIDEBAR_SERIES
if "show_category" in to_save and not content.show_category():
content.sidebar_view += ub.SIDEBAR_CATEGORY
elif "show_category" not in to_save and content.show_category():
content.sidebar_view -= ub.SIDEBAR_CATEGORY
if "show_hot" in to_save and not content.show_hot_books():
content.sidebar_view += ub.SIDEBAR_HOT
elif "show_hot" not in to_save and content.show_hot_books():
content.sidebar_view -= ub.SIDEBAR_HOT
if "show_author" in to_save and not content.show_author():
content.sidebar_view += ub.SIDEBAR_AUTHOR
elif "show_author" not in to_save and content.show_author():
content.sidebar_view -= ub.SIDEBAR_AUTHOR
if "show_detail_random" in to_save and not content.show_detail_random():
content.sidebar_view += ub.DETAIL_RANDOM
elif "show_detail_random" not in to_save and content.show_detail_random():
content.sidebar_view -= ub.DETAIL_RANDOM
if "default_language" in to_save: if "default_language" in to_save:
content.default_language = to_save["default_language"] content.default_language = to_save["default_language"]
if "locale" in to_save and to_save["locale"]: if "locale" in to_save and to_save["locale"]:
@ -1759,7 +1827,8 @@ def edit_user(user_id):
ub.session.rollback() ub.session.rollback()
flash(_(u"An unknown error occured."), category="error") flash(_(u"An unknown error occured."), category="error")
return render_title_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)) content=content, downloads=downloads,
title=_(u"Edit User %(nick)s", nick=content.nickname))
@app.route("/admin/book/<int:book_id>", methods=['GET', 'POST']) @app.route("/admin/book/<int:book_id>", methods=['GET', 'POST'])
@ -1963,9 +2032,11 @@ def edit_book(book_id):
if "detail_view" in to_save: if "detail_view" in to_save:
return redirect(url_for('show_book', id=book.id)) return redirect(url_for('show_book', id=book.id))
else: else:
return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc, title=_(u"edit metadata")) return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc,
title=_(u"edit metadata"))
else: else:
return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc, title=_(u"edit metadata")) return render_title_template('book_edit.html', book=book, authors=author_names, cc=cc,
title=_(u"edit metadata"))
else: else:
flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error") flash(_(u"Error opening eBook. File does not exist or file is not accessible:"), category="error")
return redirect(url_for("index")) return redirect(url_for("index"))
@ -2038,6 +2109,8 @@ def upload():
author_names.append(author.name) author_names.append(author.name)
cc = db.session.query(db.Custom_Columns).filter(db.Custom_Columns.datatype.notin_(db.cc_exceptions)).all() 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(): if current_user.role_edit() or current_user.role_admin():
return render_title_template('book_edit.html', book=db_book, authors=author_names, cc=cc, title=_(u"edit metadata")) return render_title_template('book_edit.html', book=db_book, authors=author_names, cc=cc,
title=_(u"edit metadata"))
book_in_shelfs = [] book_in_shelfs = []
return render_title_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, )