185 lines
6.4 KiB
Python
185 lines
6.4 KiB
Python
import logging
|
|
from uuid import uuid4
|
|
|
|
import requests
|
|
from books.openlibrary import (
|
|
lookup_author_from_openlibrary,
|
|
lookup_book_from_openlibrary,
|
|
)
|
|
from django.conf import settings
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.files.base import ContentFile
|
|
from django.db import models
|
|
from django.urls import reverse
|
|
from django_extensions.db.models import TimeStampedModel
|
|
from scrobbles.mixins import LongPlayScrobblableMixin, ScrobblableMixin
|
|
from scrobbles.utils import get_scrobbles_for_media
|
|
|
|
logger = logging.getLogger(__name__)
|
|
User = get_user_model()
|
|
BNULL = {"blank": True, "null": True}
|
|
|
|
|
|
class Author(TimeStampedModel):
|
|
name = models.CharField(max_length=255)
|
|
uuid = models.UUIDField(default=uuid4, editable=False, **BNULL)
|
|
openlibrary_id = models.CharField(max_length=255, **BNULL)
|
|
headshot = models.ImageField(upload_to="books/authors/", **BNULL)
|
|
bio = models.TextField(**BNULL)
|
|
wikipedia_url = models.CharField(max_length=255, **BNULL)
|
|
isni = models.CharField(max_length=255, **BNULL)
|
|
wikidata_id = models.CharField(max_length=255, **BNULL)
|
|
goodreads_id = models.CharField(max_length=255, **BNULL)
|
|
librarything_id = models.CharField(max_length=255, **BNULL)
|
|
amazon_id = models.CharField(max_length=255, **BNULL)
|
|
|
|
def __str__(self):
|
|
return f"{self.name}"
|
|
|
|
def fix_metadata(self, data_dict: dict = {}):
|
|
if not data_dict and self.openlibrary_id:
|
|
data_dict = lookup_author_from_openlibrary(self.openlibrary_id)
|
|
|
|
if not data_dict or not data_dict.get("name"):
|
|
return
|
|
|
|
headshot_url = data_dict.pop("author_headshot_url", "")
|
|
|
|
Author.objects.filter(pk=self.id).update(**data_dict)
|
|
self.refresh_from_db()
|
|
|
|
if headshot_url:
|
|
r = requests.get(headshot_url)
|
|
if r.status_code == 200:
|
|
fname = f"{self.name}_{self.uuid}.jpg"
|
|
self.headshot.save(fname, ContentFile(r.content), save=True)
|
|
|
|
|
|
class Book(LongPlayScrobblableMixin):
|
|
COMPLETION_PERCENT = getattr(settings, "BOOK_COMPLETION_PERCENT", 95)
|
|
AVG_PAGE_READING_SECONDS = getattr(
|
|
settings, "AVERAGE_PAGE_READING_SECONDS", 60
|
|
)
|
|
|
|
title = models.CharField(max_length=255)
|
|
authors = models.ManyToManyField(Author)
|
|
goodreads_id = models.CharField(max_length=255, **BNULL)
|
|
koreader_id = models.IntegerField(**BNULL)
|
|
koreader_authors = models.CharField(max_length=255, **BNULL)
|
|
koreader_md5 = models.CharField(max_length=255, **BNULL)
|
|
isbn = models.CharField(max_length=255, **BNULL)
|
|
pages = models.IntegerField(**BNULL)
|
|
language = models.CharField(max_length=4, **BNULL)
|
|
first_publish_year = models.IntegerField(**BNULL)
|
|
first_sentence = models.CharField(max_length=255, **BNULL)
|
|
openlibrary_id = models.CharField(max_length=255, **BNULL)
|
|
cover = models.ImageField(upload_to="books/covers/", **BNULL)
|
|
|
|
def __str__(self):
|
|
return f"{self.title} by {self.author}"
|
|
|
|
@property
|
|
def subtitle(self):
|
|
return f" by {self.author}"
|
|
|
|
def get_start_url(self):
|
|
return reverse("scrobbles:start", kwargs={"uuid": self.uuid})
|
|
|
|
def get_absolute_url(self):
|
|
return reverse("books:book_detail", kwargs={"slug": self.uuid})
|
|
|
|
def fix_metadata(self, force_update=False):
|
|
if not self.openlibrary_id or force_update:
|
|
book_dict = lookup_book_from_openlibrary(self.title, self.author)
|
|
|
|
cover_url = book_dict.pop("cover_url", "")
|
|
ol_author_id = book_dict.pop("ol_author_id", "")
|
|
ol_author_name = book_dict.pop("ol_author_name", "")
|
|
# Don't want to overwrite KoReader's pages if OL is ignorant
|
|
if not book_dict.get("pages"):
|
|
book_dict.pop("pages")
|
|
|
|
ol_title = book_dict.get("title")
|
|
if ol_title.lower() != self.title.lower():
|
|
logger.warn(
|
|
f"OL and KoReader disagree on this book title {self.title} != {ol_title}"
|
|
)
|
|
return
|
|
|
|
Book.objects.filter(pk=self.id).update(**book_dict)
|
|
self.refresh_from_db()
|
|
|
|
# Process authors
|
|
author = None
|
|
author_created = False
|
|
if ol_author_id:
|
|
author, author_created = Author.objects.get_or_create(
|
|
openlibrary_id=ol_author_id
|
|
)
|
|
if author_created or force_update:
|
|
author.fix_metadata()
|
|
if not author and ol_author_name:
|
|
author, author_created = Author.objects.get_or_create(
|
|
name=ol_author_name
|
|
)
|
|
self.authors.add(author)
|
|
|
|
if cover_url:
|
|
r = requests.get(cover_url)
|
|
if r.status_code == 200:
|
|
fname = f"{self.title}_{self.uuid}.jpg"
|
|
self.cover.save(fname, ContentFile(r.content), save=True)
|
|
|
|
if self.pages:
|
|
self.run_time_seconds = self.pages * int(
|
|
self.AVG_PAGE_READING_SECONDS
|
|
)
|
|
|
|
self.save()
|
|
|
|
@property
|
|
def author(self):
|
|
return self.authors.first()
|
|
|
|
@property
|
|
def pages_for_completion(self) -> int:
|
|
if not self.pages:
|
|
logger.warn(f"{self} has no pages, no completion percentage")
|
|
return 0
|
|
return int(self.pages * (self.COMPLETION_PERCENT / 100))
|
|
|
|
def update_long_play_seconds(self):
|
|
"""Check page timestamps and duration and update"""
|
|
if self.page_set.all():
|
|
...
|
|
|
|
def progress_for_user(self, user_id: int) -> int:
|
|
"""Used to keep track of whether the book is complete or not"""
|
|
user = User.objects.get(id=user_id)
|
|
last_scrobble = get_scrobbles_for_media(self, user).last()
|
|
return int((last_scrobble.book_pages_read / self.pages) * 100)
|
|
|
|
@classmethod
|
|
def find_or_create(cls, data_dict: dict) -> "Game":
|
|
from books.utils import update_or_create_book
|
|
|
|
return update_or_create_book(
|
|
data_dict.get("title"), data_dict.get("author")
|
|
)
|
|
|
|
|
|
class Page(TimeStampedModel):
|
|
book = models.ForeignKey(Book, on_delete=models.CASCADE)
|
|
number = models.IntegerField()
|
|
start_time = models.DateTimeField(**BNULL)
|
|
duration_seconds = models.IntegerField(**BNULL)
|
|
|
|
class Meta:
|
|
unique_together = (
|
|
"book",
|
|
"number",
|
|
)
|
|
|
|
def __str__(self):
|
|
return f"Page {self.number} of {self.book.pages} in {self.book.title}"
|