Książka ma {0} stron(y).
" + TRANSLATOR_TEMPLATE = "Tłumacz: {0}
" + PUBLISH_DATE_TEMPLATE = "Data pierwszego wydania: {0}
" + PUBLISH_DATE_PL_TEMPLATE = ( + "Data pierwszego wydania w Polsce: {0}
" + ) + + def __init__(self, root: HtmlElement, metadata: Metadata) -> None: + self.root = root + self.metadata = metadata + + def parse_search_results(self) -> List[MetaRecord]: + matches = [] + results = self.root.xpath(LubimyCzytac.BOOK_SEARCH_RESULT_XPATH) + for result in results: + title = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.TITLE_TEXT_PATH}", + ) + + book_url = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.URL_PATH}", + ) + authors = self._parse_xpath_node( + root=result, + xpath=f"{LubimyCzytac.SINGLE_BOOK_RESULT_XPATH}" + f"{LubimyCzytac.AUTHORS_PATH}", + take_first=False, + ) + if not all([title, book_url, authors]): + continue + matches.append( + MetaRecord( + id=book_url.replace(f"/ksiazka/", "").split("/")[0], + title=title, + authors=[strip_accents(author) for author in authors], + url=LubimyCzytac.BASE_URL + book_url, + source=MetaSourceInfo( + id=self.metadata.__id__, + description=self.metadata.__name__, + link=LubimyCzytac.BASE_URL, + ), + ) + ) + return matches + + def parse_single_book( + self, match: MetaRecord, generic_cover: str, locale: str + ) -> MetaRecord: + try: + response = requests.get(match.url) + response.raise_for_status() + except Exception as e: + log.warning(e) + return None + self.root = fromstring(response.text) + match.cover = self._parse_cover(generic_cover=generic_cover) + match.description = self._parse_description() + match.languages = self._parse_languages(locale=locale) + match.publisher = self._parse_publisher() + match.publishedDate = self._parse_from_summary(attribute_name="datePublished") + match.rating = self._parse_rating() + match.series, match.series_index = self._parse_series() + match.tags = self._parse_tags() + match.identifiers = { + "isbn": self._parse_isbn(), + "lubimyczytac": match.id, + } + return match + + def _parse_xpath_node( + self, + xpath: str, + root: HtmlElement = None, + take_first: bool = True, + strip_element: bool = True, + ) -> Optional[Union[str, List[str]]]: + root = root if root is not None else self.root + node = root.xpath(xpath) + if not node: + return None + return ( + (node[0].strip() if strip_element else node[0]) + if take_first + else [x.strip() for x in node] + ) + + def _parse_cover(self, generic_cover) -> Optional[str]: + return ( + self._parse_xpath_node(xpath=LubimyCzytac.COVER, take_first=True) + or generic_cover + ) + + def _parse_publisher(self) -> Optional[str]: + return self._parse_xpath_node(xpath=LubimyCzytac.PUBLISHER, take_first=True) + + def _parse_languages(self, locale: str) -> List[str]: + languages = list() + lang = self._parse_xpath_node(xpath=LubimyCzytac.LANGUAGES, take_first=True) + if lang: + if "polski" in lang: + languages.append("pol") + if "angielski" in lang: + languages.append("eng") + return [get_language_name(locale, language) for language in languages] + + def _parse_series(self) -> Tuple[Optional[str], Optional[Union[float, int]]]: + series_index = 0 + series = self._parse_xpath_node(xpath=LubimyCzytac.SERIES, take_first=True) + if series: + if "tom " in series: + series_name, series_info = series.split(" (tom ", 1) + series_info = series_info.replace(" ", "").replace(")", "") + # Check if book is not a bundle, i.e. chapter 1-3 + if "-" in series_info: + series_info = series_info.split("-", 1)[0] + if series_info.replace(".", "").isdigit() is True: + series_index = get_int_or_float(series_info) + return series_name, series_index + return None, None + + def _parse_tags(self) -> List[str]: + tags = self._parse_xpath_node(xpath=LubimyCzytac.TAGS, take_first=False) + if tags: + return [ + strip_accents(w.replace(", itd.", " itd.")) + for w in tags + if isinstance(w, str) + ] + return None + + def _parse_from_summary(self, attribute_name: str) -> Optional[str]: + value = None + summary_text = self._parse_xpath_node(xpath=LubimyCzytac.SUMMARY) + if summary_text: + data = json.loads(summary_text) + value = data.get(attribute_name) + return value.strip() if value is not None else value + + def _parse_rating(self) -> Optional[str]: + rating = self._parse_xpath_node(xpath=LubimyCzytac.RATING) + return round(float(rating.replace(",", ".")) / 2) if rating else rating + + def _parse_date(self, xpath="first_publish") -> Optional[datetime.datetime]: + options = { + "first_publish": LubimyCzytac.FIRST_PUBLISH_DATE, + "first_publish_pl": LubimyCzytac.FIRST_PUBLISH_DATE_PL, + } + date = self._parse_xpath_node(xpath=options.get(xpath)) + return parser.parse(date) if date else None + + def _parse_isbn(self) -> Optional[str]: + return self._parse_xpath_node(xpath=LubimyCzytac.ISBN) + + def _parse_description(self) -> str: + description = "" + description_node = self._parse_xpath_node( + xpath=LubimyCzytac.DESCRIPTION, strip_element=False + ) + if description_node is not None: + for source in self.root.xpath('//p[@class="source"]'): + source.getparent().remove(source) + description = tostring(description_node, method="html") + description = sanitize_comments_html(description) + + else: + description_node = self._parse_xpath_node(xpath=LubimyCzytac.META_TITLE) + if description_node is not None: + description = description_node + description = sanitize_comments_html(description) + description = self._add_extra_info_to_description(description=description) + return description + + def _add_extra_info_to_description(self, description: str) -> str: + pages = self._parse_from_summary(attribute_name="numberOfPages") + if pages: + description += LubimyCzytacParser.PAGES_TEMPLATE.format(pages) + + first_publish_date = self._parse_date() + if first_publish_date: + description += LubimyCzytacParser.PUBLISH_DATE_TEMPLATE.format( + first_publish_date.strftime("%d.%m.%Y") + ) + + first_publish_date_pl = self._parse_date(xpath="first_publish_pl") + if first_publish_date_pl: + description += LubimyCzytacParser.PUBLISH_DATE_PL_TEMPLATE.format( + first_publish_date_pl.strftime("%d.%m.%Y") + ) + translator = self._parse_xpath_node(xpath=LubimyCzytac.TRANSLATOR) + if translator: + description += LubimyCzytacParser.TRANSLATOR_TEMPLATE.format(translator) + + + return description diff --git a/root/app/calibre-web/cps/metadata_provider/scholar.py b/root/app/calibre-web/cps/metadata_provider/scholar.py new file mode 100644 index 0000000..b3bfbb7 --- /dev/null +++ b/root/app/calibre-web/cps/metadata_provider/scholar.py @@ -0,0 +1,83 @@ +# -*- coding: utf-8 -*- + +# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web) +# Copyright (C) 2021 OzzieIsaacs +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see }}){kind=icon}
+
+{% endblock %}
+{% block modal %}
+{{ filechooser_modal() }}
+{% endblock %}
diff --git a/root/app/calibre-web/cps/templates/detail.html b/root/app/calibre-web/cps/templates/detail.html
new file mode 100644
index 0000000..bc3ab48
--- /dev/null
+++ b/root/app/calibre-web/cps/templates/detail.html
@@ -0,0 +1,377 @@
+{% extends is_xhr|yesno("fragment.html", "layout.html") %}
+{% block header %}
+
+
+ {% if entry.comments|length > 0 and entry.comments[0].text|length > 0 %}
+
+
+ {% endif %}
+{% endblock %}
+{% block body %}
+{{title}}
+ +
+ ' % self.name
+
+
+# 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'
+ __table_args__ = {'sqlite_autoincrement': True}
+
+ id = Column(Integer, primary_key=True)
+ name = Column(String(64), unique=True)
+ email = Column(String(120), unique=True, default="")
+ role = Column(SmallInteger, default=constants.ROLE_USER)
+ password = Column(String)
+ kindle_mail = Column(String(120), default="")
+ shelf = relationship('Shelf', backref='user', lazy='dynamic', order_by='Shelf.name')
+ downloads = relationship('Downloads', backref='user', lazy='dynamic')
+ locale = Column(String(2), default="en")
+ sidebar_view = Column(Integer, default=1)
+ default_language = Column(String(3), default="all")
+ denied_tags = Column(String, default="")
+ allowed_tags = Column(String, default="")
+ denied_column_value = Column(String, default="")
+ allowed_column_value = Column(String, default="")
+ remote_auth_token = relationship('RemoteAuthToken', backref='user', lazy='dynamic')
+ view_settings = Column(JSON, default={})
+ kobo_only_shelves_sync = Column(Integer, default=0)
+ hardcover_token = Column(String, unique=True, default="")
+
+
+if oauth_support:
+ class OAuth(OAuthConsumerMixin, Base):
+ provider_user_id = Column(String(256))
+ user_id = Column(Integer, ForeignKey(User.id))
+ user = relationship(User)
+
+
+class OAuthProvider(Base):
+ __tablename__ = 'oauthProvider'
+
+ id = Column(Integer, primary_key=True)
+ provider_name = Column(String)
+ oauth_client_id = Column(String)
+ oauth_client_secret = Column(String)
+ active = Column(Boolean)
+
+
+# Class for anonymous user is derived from User base and completely overrides methods and properties for the
+# anonymous user
+class Anonymous(AnonymousUserMixin, UserBase):
+ def __init__(self):
+ self.kobo_only_shelves_sync = None
+ self.view_settings = None
+ self.allowed_column_value = None
+ self.allowed_tags = None
+ self.denied_tags = None
+ self.kindle_mail = None
+ self.locale = None
+ self.default_language = None
+ self.sidebar_view = None
+ self.id = None
+ self.role = None
+ self.name = None
+ self.loadSettings()
+
+ def loadSettings(self):
+ data = session.query(User).filter(User.role.op('&')(constants.ROLE_ANONYMOUS) == constants.ROLE_ANONYMOUS)\
+ .first() # type: User
+ self.name = data.name
+ self.role = data.role
+ self.id=data.id
+ self.sidebar_view = data.sidebar_view
+ self.default_language = data.default_language
+ self.locale = data.locale
+ self.kindle_mail = data.kindle_mail
+ self.denied_tags = data.denied_tags
+ self.allowed_tags = data.allowed_tags
+ self.denied_column_value = data.denied_column_value
+ self.allowed_column_value = data.allowed_column_value
+ self.view_settings = data.view_settings
+ self.kobo_only_shelves_sync = data.kobo_only_shelves_sync
+
+ def role_admin(self):
+ return False
+
+ @property
+ def is_active(self):
+ return False
+
+ @property
+ def is_anonymous(self):
+ return True
+
+ @property
+ def is_authenticated(self):
+ return False
+
+ def get_view_property(self, page, prop):
+ if 'view' in flask_session:
+ if not flask_session['view'].get(page):
+ return None
+ return flask_session['view'][page].get(prop)
+ return None
+
+ def set_view_property(self, page, prop, value):
+ if not 'view' in flask_session:
+ flask_session['view'] = dict()
+ if not flask_session['view'].get(page):
+ flask_session['view'][page] = dict()
+ flask_session['view'][page][prop] = value
+
+class User_Sessions(Base):
+ __tablename__ = 'user_session'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ session_key = Column(String, default="")
+ random = Column(String, default="")
+ expiry = Column(Integer)
+
+
+ def __init__(self, user_id, session_key, random, expiry):
+ super().__init__()
+ self.user_id = user_id
+ self.session_key = session_key
+ self.random = random
+ self.expiry = expiry
+
+
+# Baseclass representing Shelfs in calibre-web in app.db
+class Shelf(Base):
+ __tablename__ = 'shelf'
+
+ id = Column(Integer, primary_key=True)
+ uuid = Column(String, default=lambda: str(uuid.uuid4()))
+ name = Column(String)
+ is_public = Column(Integer, default=0)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ kobo_sync = Column(Boolean, default=False)
+ books = relationship("BookShelf", backref="ub_shelf", cascade="all, delete-orphan", lazy="dynamic")
+ created = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+
+ def __repr__(self):
+ return '' % (self.id, 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'))
+ date_added = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+ def __repr__(self):
+ return '' % self.id
+
+
+# This table keeps track of deleted Shelves so that deletes can be propagated to any paired Kobo device.
+class ShelfArchive(Base):
+ __tablename__ = 'shelf_archive'
+
+ id = Column(Integer, primary_key=True)
+ uuid = Column(String)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+
+class ReadBook(Base):
+ __tablename__ = 'book_read_link'
+
+ STATUS_UNREAD = 0
+ STATUS_FINISHED = 1
+ STATUS_IN_PROGRESS = 2
+
+ id = Column(Integer, primary_key=True)
+ book_id = Column(Integer, unique=False)
+ user_id = Column(Integer, ForeignKey('user.id'), unique=False)
+ read_status = Column(Integer, unique=False, default=STATUS_UNREAD, nullable=False)
+ kobo_reading_state = relationship("KoboReadingState", uselist=False,
+ primaryjoin="and_(ReadBook.user_id == foreign(KoboReadingState.user_id), "
+ "ReadBook.book_id == foreign(KoboReadingState.book_id))",
+ cascade="all",
+ backref=backref("book_read_link",
+ uselist=False))
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+ last_time_started_reading = Column(DateTime, nullable=True)
+ times_started_reading = Column(Integer, default=0, nullable=False)
+
+
+class Bookmark(Base):
+ __tablename__ = 'bookmark'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ book_id = Column(Integer)
+ format = Column(String(collation='NOCASE'))
+ bookmark_key = Column(String)
+
+
+# Baseclass representing books that are archived on the user's Kobo device.
+class ArchivedBook(Base):
+ __tablename__ = 'archived_book'
+
+ id = Column(Integer, primary_key=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ book_id = Column(Integer)
+ is_archived = Column(Boolean, unique=False)
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+
+class KoboSyncedBooks(Base):
+ __tablename__ = 'kobo_synced_books'
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ book_id = Column(Integer)
+
+# The Kobo ReadingState API keeps track of 4 timestamped entities:
+# ReadingState, StatusInfo, Statistics, CurrentBookmark
+# Which we map to the following 4 tables:
+# KoboReadingState, ReadBook, KoboStatistics and KoboBookmark
+class KoboReadingState(Base):
+ __tablename__ = 'kobo_reading_state'
+
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ book_id = Column(Integer)
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+ priority_timestamp = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+ current_bookmark = relationship("KoboBookmark", uselist=False, backref="kobo_reading_state", cascade="all, delete")
+ statistics = relationship("KoboStatistics", uselist=False, backref="kobo_reading_state", cascade="all, delete")
+
+
+class KoboBookmark(Base):
+ __tablename__ = 'kobo_bookmark'
+
+ id = Column(Integer, primary_key=True)
+ kobo_reading_state_id = Column(Integer, ForeignKey('kobo_reading_state.id'))
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+ location_source = Column(String)
+ location_type = Column(String)
+ location_value = Column(String)
+ progress_percent = Column(Float)
+ content_source_progress_percent = Column(Float)
+
+
+class KoboStatistics(Base):
+ __tablename__ = 'kobo_statistics'
+
+ id = Column(Integer, primary_key=True)
+ kobo_reading_state_id = Column(Integer, ForeignKey('kobo_reading_state.id'))
+ last_modified = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+ remaining_time_minutes = Column(Integer)
+ spent_reading_minutes = Column(Integer)
+
+
+# Updates the last_modified timestamp in the KoboReadingState table if any of its children tables are modified.
+@event.listens_for(Session, 'before_flush')
+def receive_before_flush(session, flush_context, instances):
+ for change in itertools.chain(session.new, session.dirty):
+ if isinstance(change, (ReadBook, KoboStatistics, KoboBookmark)):
+ if change.kobo_reading_state:
+ change.kobo_reading_state.last_modified = datetime.now(timezone.utc)
+ # Maintain the last_modified_bit for the Shelf table.
+ for change in itertools.chain(session.new, session.deleted):
+ if isinstance(change, BookShelf):
+ change.ub_shelf.last_modified = datetime.now(timezone.utc)
+
+
+# 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 '".format(self.domain)
+
+
+class RemoteAuthToken(Base):
+ __tablename__ = 'remote_auth_token'
+
+ id = Column(Integer, primary_key=True)
+ auth_token = Column(String, unique=True)
+ user_id = Column(Integer, ForeignKey('user.id'))
+ verified = Column(Boolean, default=False)
+ expiration = Column(DateTime)
+ token_type = Column(Integer, default=0)
+
+ def __init__(self):
+ super().__init__()
+ self.auth_token = (hexlify(os.urandom(4))).decode('utf-8')
+ self.expiration = datetime.now() + timedelta(minutes=10) # 10 min from now
+
+ def __repr__(self):
+ return '' % self.id
+
+
+def filename(context):
+ file_format = context.get_current_parameters()['format']
+ if file_format == 'jpeg':
+ return context.get_current_parameters()['uuid'] + '.jpg'
+ else:
+ return context.get_current_parameters()['uuid'] + '.' + file_format
+
+
+class Thumbnail(Base):
+ __tablename__ = 'thumbnail'
+
+ id = Column(Integer, primary_key=True)
+ entity_id = Column(Integer)
+ uuid = Column(String, default=lambda: str(uuid.uuid4()), unique=True)
+ format = Column(String, default='jpeg')
+ type = Column(SmallInteger, default=constants.THUMBNAIL_TYPE_COVER)
+ resolution = Column(SmallInteger, default=constants.COVER_THUMBNAIL_SMALL)
+ filename = Column(String, default=filename)
+ generated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+ expiration = Column(DateTime, nullable=True)
+
+
+# Add missing tables during migration of database
+def add_missing_tables(engine, _session):
+ if not engine.dialect.has_table(engine.connect(), "archived_book"):
+ ArchivedBook.__table__.create(bind=engine)
+ if not engine.dialect.has_table(engine.connect(), "thumbnail"):
+ Thumbnail.__table__.create(bind=engine)
+
+
+# migrate all settings missing in registration table
+def migrate_registration_table(engine, _session):
+ try:
+ # Handle table exists, but no content
+ cnt = _session.query(Registration).count()
+ if not cnt:
+ with engine.connect() as conn:
+ trans = conn.begin()
+ conn.execute(text("insert into registration (domain, allow) values('%.%',1)"))
+ trans.commit()
+ except exc.OperationalError: # Database is not writeable
+ print('Settings database is not writeable. Exiting...')
+ sys.exit(2)
+
+
+def migrate_user_session_table(engine, _session):
+ try:
+ _session.query(exists().where(User_Sessions.random)).scalar()
+ _session.commit()
+ except exc.OperationalError: # Database is not compatible, some columns are missing
+ with engine.connect() as conn:
+ trans = conn.begin()
+ conn.execute(text("ALTER TABLE user_session ADD column 'random' String"))
+ conn.execute(text("ALTER TABLE user_session ADD column 'expiry' Integer"))
+ trans.commit()
+
+def migrate_user_table(engine, _session):
+ try:
+ _session.query(exists().where(User.hardcover_token)).scalar()
+ _session.commit()
+ except exc.OperationalError: # Database is not compatible, some columns are missing
+ with engine.connect() as conn:
+ trans = conn.begin()
+ conn.execute(text("ALTER TABLE user ADD column 'hardcover_token' String"))
+ trans.commit()
+
+# Migrate database to current version, has to be updated after every database change. Currently migration from
+# maybe 4/5 versions back to current should work.
+# Migration is done by checking if relevant columns are existing, and then adding rows with SQL commands
+def migrate_Database(_session):
+ engine = _session.bind
+ add_missing_tables(engine, _session)
+ migrate_registration_table(engine, _session)
+ migrate_user_session_table(engine, _session)
+
+
+def clean_database(_session):
+ # Remove expired remote login tokens
+ now = datetime.now()
+ try:
+ _session.query(RemoteAuthToken).filter(now > RemoteAuthToken.expiration).\
+ filter(RemoteAuthToken.token_type != 1).delete()
+ _session.commit()
+ except exc.OperationalError: # Database is not writeable
+ print('Settings database is not writeable. Exiting...')
+ sys.exit(2)
+
+
+# Save downloaded books per user in calibre-web's own database
+def update_download(book_id, user_id):
+ check = session.query(Downloads).filter(Downloads.user_id == user_id).filter(Downloads.book_id == book_id).first()
+
+ if not check:
+ new_download = Downloads(user_id=user_id, book_id=book_id)
+ session.add(new_download)
+ try:
+ session.commit()
+ except exc.OperationalError:
+ session.rollback()
+
+
+# Delete non existing downloaded books in calibre-web's own database
+def delete_download(book_id):
+ session.query(Downloads).filter(book_id == Downloads.book_id).delete()
+ try:
+ session.commit()
+ except exc.OperationalError:
+ session.rollback()
+
+# Generate user Guest (translated text), as anonymous user, no rights
+def create_anonymous_user(_session):
+ user = User()
+ user.name = "Guest"
+ user.email = 'no@email'
+ user.role = constants.ROLE_ANONYMOUS
+ user.password = ''
+
+ _session.add(user)
+ try:
+ _session.commit()
+ except Exception:
+ _session.rollback()
+
+
+# Generate User admin with admin123 password, and access to everything
+def create_admin_user(_session):
+ user = User()
+ user.name = "admin"
+ user.email = "admin@example.org"
+ user.role = constants.ADMIN_USER_ROLES
+ user.sidebar_view = constants.ADMIN_USER_SIDEBAR
+
+ user.password = generate_password_hash(constants.DEFAULT_PASSWORD)
+
+ _session.add(user)
+ try:
+ _session.commit()
+ except Exception:
+ _session.rollback()
+
+def init_db_thread():
+ global app_DB_path
+ engine = create_engine('sqlite:///{0}'.format(app_DB_path), echo=False)
+
+ Session = scoped_session(sessionmaker())
+ Session.configure(bind=engine)
+ return Session()
+
+
+def init_db(app_db_path):
+ # Open session for database connection
+ global session
+ global app_DB_path
+
+ app_DB_path = app_db_path
+ engine = create_engine('sqlite:///{0}'.format(app_db_path), echo=False)
+
+ Session = scoped_session(sessionmaker())
+ Session.configure(bind=engine)
+ session = Session()
+
+ if os.path.exists(app_db_path):
+ Base.metadata.create_all(engine)
+ migrate_Database(session)
+ clean_database(session)
+ else:
+ Base.metadata.create_all(engine)
+ create_admin_user(session)
+ create_anonymous_user(session)
+
+def password_change(user_credentials=None):
+ if user_credentials:
+ username, password = user_credentials.split(':', 1)
+ user = session.query(User).filter(func.lower(User.name) == username.lower()).first()
+ if user:
+ if not password:
+ print("Empty password is not allowed")
+ sys.exit(4)
+ try:
+ from .helper import valid_password
+ user.password = generate_password_hash(valid_password(password))
+ except Exception:
+ print("Password doesn't comply with password validation rules")
+ sys.exit(4)
+ if session_commit() == "":
+ print("Password for user '{}' changed".format(username))
+ sys.exit(0)
+ else:
+ print("Failed changing password")
+ sys.exit(3)
+ else:
+ print("Username '{}' not valid, can't change password".format(username))
+ sys.exit(3)
+
+
+def get_new_session_instance():
+ new_engine = create_engine('sqlite:///{0}'.format(app_DB_path), echo=False)
+ new_session = scoped_session(sessionmaker())
+ new_session.configure(bind=new_engine)
+
+ atexit.register(lambda: new_session.remove() if new_session else True)
+
+ return new_session
+
+
+def dispose():
+ global session
+
+ old_session = session
+ session = None
+ if old_session:
+ try:
+ old_session.close()
+ except Exception:
+ pass
+ if old_session.bind:
+ try:
+ old_session.bind.dispose()
+ except Exception:
+ pass
+
+def session_commit(success=None, _session=None):
+ s = _session if _session else session
+ try:
+ s.commit()
+ if success:
+ log.info(success)
+ except (exc.OperationalError, exc.InvalidRequestError) as e:
+ s.rollback()
+ log.error_or_exception(e)
+ return ""
diff --git a/root/app/calibre-web/cps/web.py b/root/app/calibre-web/cps/web.py
index 558d768..1c16518 100644
--- a/root/app/calibre-web/cps/web.py
+++ b/root/app/calibre-web/cps/web.py
@@ -70,7 +70,8 @@ from .string_helper import strip_whitespaces
feature_support = {
'ldap': bool(services.ldap),
'goodreads': bool(services.goodreads_support),
- 'kobo': bool(services.kobo)
+ 'kobo': bool(services.kobo),
+ 'hardcover' : bool(services.hardcover)
}
try:
@@ -1232,7 +1233,7 @@ def serve_book(book_id, book_format, anyname):
try:
headers = Headers()
headers["Content-Type"] = mimetypes.types_map.get('.' + book_format, "application/octet-stream")
- if not range_header:
+ if not range_header:
log.info('Serving book: %s', data.name)
headers['Accept-Ranges'] = 'bytes'
df = getFileFromEbooksFolder(book.path, data.name + "." + book_format)
@@ -1497,7 +1498,7 @@ def logout():
# ################################### Users own configuration #########################################################
-def change_profile(kobo_support, local_oauth_check, oauth_status, translations, languages):
+def change_profile(kobo_support, hardcover_support, local_oauth_check, oauth_status, translations, languages):
to_save = request.form.to_dict()
current_user.random_books = 0
try:
@@ -1525,6 +1526,7 @@ def change_profile(kobo_support, local_oauth_check, oauth_status, translations,
current_user.kobo_only_shelves_sync = int(to_save.get("kobo_only_shelves_sync") == "on") or 0
if old_state == 0 and current_user.kobo_only_shelves_sync == 1:
kobo_sync_status.update_on_sync_shelfs(current_user.id)
+ current_user.hardcover_token = to_save.get("hardcover_token","").replace("Bearer ","")
except Exception as ex:
flash(str(ex), category="error")
@@ -1537,6 +1539,7 @@ def change_profile(kobo_support, local_oauth_check, oauth_status, translations,
title=_("%(name)s's Profile", name=current_user.name),
page="me",
kobo_support=kobo_support,
+ hardcover_support=hardcover_support,
registered_oauth=local_oauth_check,
oauth_status=oauth_status)
@@ -1568,6 +1571,7 @@ def profile():
languages = calibre_db.speaking_language()
translations = get_available_locale()
kobo_support = feature_support['kobo'] and config.config_kobo_sync
+ hardcover_support = feature_support['hardcover'] and config.config_hardcover_sync
if feature_support['oauth'] and config.config_login_type == 2:
oauth_status = get_oauth_status()
local_oauth_check = oauth_check
@@ -1576,7 +1580,7 @@ def profile():
local_oauth_check = {}
if request.method == "POST":
- change_profile(kobo_support, local_oauth_check, oauth_status, translations, languages)
+ change_profile(kobo_support, hardcover_support, local_oauth_check, oauth_status, translations, languages)
return render_title_template("user_edit.html",
translations=translations,
profile=1,
@@ -1584,6 +1588,7 @@ def profile():
content=current_user,
config=config,
kobo_support=kobo_support,
+ hardcover_support=hardcover_support,
title=_("%(name)s's Profile", name=current_user.name),
page="me",
registered_oauth=local_oauth_check,
+
+{% endblock %}
+
+{% block js %}
+
+
+
+
+
+
+{% endblock %}
diff --git a/root/app/calibre-web/cps/templates/user_edit.html b/root/app/calibre-web/cps/templates/user_edit.html
new file mode 100644
index 0000000..ed3b7b1
--- /dev/null
+++ b/root/app/calibre-web/cps/templates/user_edit.html
@@ -0,0 +1,189 @@
+{% extends "layout.html" %}
+{% block body %}
+
+
+
+
+
+  }} "{{ entry.title }}")
+
+
+
+
+{{title}}
+ +
+
+
+{% endblock %}
+{% block modal %}
+{{ restrict_modal() }}
+{{ delete_confirm_modal() }}
+{% endblock %}
+{% block js %}
+
+
+
+
+
+
+
+
+{% endblock %}
diff --git a/root/app/calibre-web/cps/ub.py b/root/app/calibre-web/cps/ub.py
new file mode 100644
index 0000000..f0ba832
--- /dev/null
+++ b/root/app/calibre-web/cps/ub.py
@@ -0,0 +1,778 @@
+# -*- coding: utf-8 -*-
+
+# This file is part of the Calibre-Web (https://github.com/janeczku/calibre-web)
+# Copyright (C) 2012-2019 mutschler, jkrehm, cervinko, janeczku, OzzieIsaacs, csitko
+# ok11, issmirnov, idalin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see
+
+
+
{{ _('Description:') }}
+ {{ entry.comments[0].text|safe }} +