import logging from datetime import timedelta 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}" @property def primary_image_url(self) -> str: url = "" if self.cover: url = self.cover.url return url 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, data: dict = {}, force_update=False): if not self.openlibrary_id or force_update: author_name = "" if self.author: author_name = self.author.name if not data: data = lookup_book_from_openlibrary( str(self.title), author_name ) if not data: logger.warn(f"Book not found in OL {self.title}") return # We can discard the author name from OL for now, we'll lookup details below data.pop("ol_author_name", "") self.fix_authors_metadata(data.pop("ol_author_id", "")) ol_title = data.get("title", "") # Kick out a little warning if we're about to change KoReader's title if ol_title.lower() != str(self.title).lower(): logger.warn( f"OL and KoReader disagree on this book title {self.title} != {ol_title}" ) # If we don't know pages, don't overwrite existing with None if data.get("pages") == None: data.pop("pages") # Pop this, so we can look it up later cover_url = data.pop("cover_url", "") # Fun trick for updating all fields at once Book.objects.filter(pk=self.id).update(**data) self.refresh_from_db() 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 = int(self.pages) * int( self.AVG_PAGE_READING_SECONDS ) self.save() def fix_authors_metadata(self, openlibrary_author_id): author = Author.objects.filter( openlibrary_id=openlibrary_author_id ).first() if not author: data = lookup_author_from_openlibrary(openlibrary_author_id) author_image_url = data.pop("author_headshot_url", None) author = Author.objects.create(**data) if author_image_url: r = requests.get(author_image_url) if r.status_code == 200: fname = f"{author.name}_{author.uuid}.jpg" author.headshot.save( fname, ContentFile(r.content), save=True ) self.authors.add(author) @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() progress = 0 if last_scrobble: progress = int((last_scrobble.book_pages_read / self.pages) * 100) return progress @classmethod def find_or_create(cls, lookup_id: str, author: str = "") -> "Book": data = lookup_book_from_openlibrary(lookup_id, author) book, book_created = cls.objects.get_or_create(isbn=data["isbn"]) if book_created: book.fix_metadata(data=data) return book class Page(TimeStampedModel): user = models.ForeignKey(User, on_delete=models.CASCADE) book = models.ForeignKey(Book, on_delete=models.CASCADE) number = models.IntegerField() start_time = models.DateTimeField(**BNULL) end_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}" def save(self, *args, **kwargs): if not self.end_time and self.duration_seconds: self._set_end_time() return super(Page, self).save(*args, **kwargs) @property def next(self): page = self.book.page_set.filter(number=self.number + 1).first() if not page: page = ( self.book.page_set.filter(created__gt=self.created) .order_by("created") .first() ) return page @property def previous(self): page = self.book.page_set.filter(number=self.number - 1).first() if not page: page = ( self.book.page_set.filter(created__lt=self.created) .order_by("-created") .first() ) return page @property def seconds_to_next_page(self) -> int: seconds = 999999 # Effectively infnity time as we have no next if not self.end_time: self._set_end_time() if self.next: seconds = (self.next.start_time - self.end_time).seconds return seconds @property def is_scrobblable(self) -> bool: """A page defines the start of a scrobble if the seconds to next page are greater than an hour, or 3600 seconds, and it's not a single page, so the next seconds to next_page is less than an hour as well. As a special case, the first recorded page is a scrobble, so we establish when the book was started. """ is_scrobblable = False over_an_hour_since_last_page = False if not self.previous: is_scrobblable = True if self.previous: over_an_hour_since_last_page = ( self.previous.seconds_to_next_page >= 3600 ) blip = self.seconds_to_next_page >= 3600 if over_an_hour_since_last_page and not blip: is_scrobblable = True return is_scrobblable def _set_end_time(self) -> None: if self.end_time: return self.end_time = self.start_time + timedelta( seconds=self.duration_seconds ) self.save(update_fields=["end_time"])