Archived
Resolve merge conflicts for PR #25: customizable mobile reading experience
- Backend: Replace PR's Book-only models with main's full models (EBook, BookChapter, DownloadRecord, ReadingProgress, ReadingSettings) - Backend: Add reader app (ReadingSettings model, serializer, view, URL) - Frontend: Port reader feature files from web/ to frontend/ (api, hooks, components/reader/, pages/ReadingPage, types/reader, reader.css) - Frontend: Add /read/:id route to App.tsx for chapter-based reading view - All imports adjusted for frontend/src directory structure
This commit is contained in:
Marko (Hermes Implementer)
+187
-17
@@ -1,11 +1,36 @@
|
||||
from django.conf import settings
|
||||
from django.db import models
|
||||
from django.db.models.signals import post_delete
|
||||
from django.dispatch import receiver
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
class ReadingStatus(models.TextChoices):
|
||||
WANT_TO_READ = "want_to_read", "Want to Read"
|
||||
READING = "reading", "Reading"
|
||||
FINISHED = "finished", "Finished"
|
||||
DNF = "dnf", "Did Not Finish"
|
||||
|
||||
|
||||
class FontStyle(models.TextChoices):
|
||||
SANS_SERIF = "sans-serif", "Sans Serif"
|
||||
SERIF = "serif", "Serif"
|
||||
MONOSPACE = "monospace", "Monospace"
|
||||
|
||||
|
||||
class BackgroundColor(models.TextChoices):
|
||||
WHITE = "#ffffff", "White"
|
||||
SEPIA = "#f4e4c1", "Sepia"
|
||||
DARK = "#1a1a2e", "Dark"
|
||||
GREEN = "#c7edcc", "Green"
|
||||
|
||||
|
||||
class Book(models.Model):
|
||||
"""Represents a book in the user's library."""
|
||||
|
||||
title = models.CharField(max_length=512)
|
||||
author = models.CharField(max_length=256, blank=True, default="")
|
||||
title = models.CharField(max_length=512, db_index=True)
|
||||
author = models.CharField(max_length=256, blank=True, default="", db_index=True)
|
||||
genre = models.CharField(max_length=128, blank=True, default="", db_index=True)
|
||||
description = models.TextField(blank=True, default="")
|
||||
reading_status = models.CharField(max_length=20, choices=ReadingStatus.choices, default=ReadingStatus.WANT_TO_READ, db_index=True)
|
||||
total_pages = models.PositiveIntegerField(default=0)
|
||||
cover_image = models.URLField(blank=True, default="")
|
||||
created_at = models.DateTimeField(auto_now_add=True)
|
||||
@@ -16,13 +41,154 @@ class Book(models.Model):
|
||||
verbose_name = "Book"
|
||||
verbose_name_plural = "Books"
|
||||
ordering = ["title"]
|
||||
indexes = [models.Index(fields=["title", "author", "genre"])]
|
||||
|
||||
def __str__(self) -> str:
|
||||
def __str__(self):
|
||||
return self.title
|
||||
|
||||
|
||||
class EBook(models.Model):
|
||||
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="ebooks")
|
||||
title = models.CharField(max_length=512, db_index=True)
|
||||
author = models.CharField(max_length=256, blank=True, default="", db_index=True)
|
||||
format = models.CharField(max_length=20, blank=True, default="", editable=False)
|
||||
page_count = models.PositiveIntegerField(default=0)
|
||||
file_size = models.BigIntegerField(default=0)
|
||||
metadata_json = models.JSONField(blank=True, default=dict)
|
||||
file = models.FileField(upload_to="ebooks/%Y/%m/%d/")
|
||||
cover_image = models.ImageField(upload_to="ebook_covers/%Y/%m/%d/", blank=True, null=True)
|
||||
created_at = models.DateTimeField(auto_now_add=True)
|
||||
updated_at = models.DateTimeField(auto_now=True)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_ebook"
|
||||
verbose_name = "E-Book"
|
||||
verbose_name_plural = "E-Books"
|
||||
ordering = ["-created_at"]
|
||||
indexes = [models.Index(fields=["user", "-created_at"])]
|
||||
|
||||
def __str__(self):
|
||||
return self.title
|
||||
|
||||
def filename(self):
|
||||
return Path(self.file.name).name if self.file else ""
|
||||
|
||||
|
||||
class BookChapter(models.Model):
|
||||
ebook = models.ForeignKey(EBook, on_delete=models.CASCADE, related_name="chapters")
|
||||
title = models.CharField(max_length=512)
|
||||
index = models.IntegerField(default=0)
|
||||
href = models.CharField(max_length=1024, blank=True, default="")
|
||||
children = models.JSONField(blank=True, default=list)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_book_chapter"
|
||||
verbose_name = "Book Chapter"
|
||||
verbose_name_plural = "Book Chapters"
|
||||
ordering = ["index"]
|
||||
indexes = [models.Index(fields=["ebook", "index"])]
|
||||
|
||||
def __str__(self):
|
||||
return f"{self.ebook.title} - {self.title}"
|
||||
|
||||
|
||||
@receiver(post_delete, sender=EBook)
|
||||
def _auto_delete_ebook_file(sender, instance, **kwargs):
|
||||
if instance.file:
|
||||
instance.file.delete(save=False)
|
||||
if instance.cover_image:
|
||||
instance.cover_image.delete(save=False)
|
||||
|
||||
|
||||
class DownloadRecord(models.Model):
|
||||
"""Tracks book downloads for offline access management."""
|
||||
|
||||
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="download_records")
|
||||
ebook = models.ForeignKey(EBook, on_delete=models.CASCADE, related_name="download_records")
|
||||
file_size = models.BigIntegerField(default=0)
|
||||
downloaded_at = models.DateTimeField(auto_now_add=True)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_download_record"
|
||||
verbose_name = "Download Record"
|
||||
verbose_name_plural = "Download Records"
|
||||
ordering = ["-downloaded_at"]
|
||||
unique_together = [("user", "ebook")]
|
||||
|
||||
def __str__(self):
|
||||
return f"{self.user} - {self.ebook.title}"
|
||||
|
||||
|
||||
class ReadingProgress(models.Model):
|
||||
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="reading_progress")
|
||||
ebook = models.OneToOneField(EBook, on_delete=models.CASCADE, related_name="reading_progress")
|
||||
current_position = models.FloatField(default=0.0)
|
||||
last_page = models.IntegerField(default=0)
|
||||
device_id = models.CharField(max_length=128, blank=True, default="")
|
||||
device_name = models.CharField(max_length=128, blank=True, default="")
|
||||
version = models.PositiveIntegerField(default=1)
|
||||
updated_at = models.DateTimeField(auto_now=True)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_reading_progress"
|
||||
verbose_name_plural = "reading progress"
|
||||
unique_together = [("user", "ebook")]
|
||||
|
||||
def __str__(self):
|
||||
return f"{self.ebook.title} - {self.current_position:.1f}%"
|
||||
|
||||
def update_with_sync(self, position: float, last_page: int,
|
||||
device_id: str, device_name: str,
|
||||
client_updated_at: str | None = None) -> tuple["ReadingProgress", bool]:
|
||||
"""Update progress with conflict resolution (last-write-wins by timestamp).
|
||||
|
||||
Returns (instance, applied) where applied is True if the update was applied.
|
||||
"""
|
||||
if client_updated_at and self.updated_at:
|
||||
try:
|
||||
from django.utils.timezone import is_naive, make_aware
|
||||
from datetime import datetime
|
||||
client_dt = datetime.fromisoformat(client_updated_at.replace("Z", "+00:00"))
|
||||
if is_naive(client_dt):
|
||||
client_dt = make_aware(client_dt)
|
||||
if client_dt <= self.updated_at:
|
||||
return self, False
|
||||
except (ValueError, TypeError):
|
||||
pass
|
||||
|
||||
self.current_position = position
|
||||
self.last_page = last_page
|
||||
self.device_id = device_id
|
||||
self.device_name = device_name
|
||||
self.version += 1
|
||||
self.save(update_fields=[
|
||||
"current_position", "last_page",
|
||||
"device_id", "device_name", "version", "updated_at",
|
||||
])
|
||||
return self, True
|
||||
|
||||
|
||||
class ReadingSettings(models.Model):
|
||||
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="reading_settings")
|
||||
font_size = models.IntegerField(default=18)
|
||||
font_style = models.CharField(max_length=20, choices=FontStyle.choices, default=FontStyle.SANS_SERIF.value)
|
||||
background_color = models.CharField(max_length=7, choices=BackgroundColor.choices, default=BackgroundColor.WHITE.value)
|
||||
updated_at = models.DateTimeField(auto_now=True)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_reading_settings"
|
||||
verbose_name_plural = "reading settings"
|
||||
|
||||
def __str__(self):
|
||||
return f"Settings for {self.user}"
|
||||
|
||||
|
||||
class Chapter(models.Model):
|
||||
"""A chapter within a book, containing the text/markdown content."""
|
||||
"""A chapter within a book, containing the text/markdown content.
|
||||
|
||||
This is distinct from BookChapter (which tracks EPUB TOC entries).
|
||||
Chapter represents user-authored chapter content for a Book.
|
||||
"""
|
||||
|
||||
book = models.ForeignKey(
|
||||
Book,
|
||||
@@ -48,23 +214,27 @@ class Chapter(models.Model):
|
||||
)
|
||||
]
|
||||
|
||||
def __str__(self) -> str:
|
||||
def __str__(self):
|
||||
return f"{self.book.title} — Ch. {self.number}: {self.title}"
|
||||
|
||||
|
||||
class ReadingProgress(models.Model):
|
||||
"""Tracks a user's reading progress within a book."""
|
||||
class BookReadingProgress(models.Model):
|
||||
"""Tracks a user's reading progress within a book's chapters.
|
||||
|
||||
This is distinct from ReadingProgress (which tracks ebook progress).
|
||||
BookReadingProgress tracks chapter-based reading for Books.
|
||||
"""
|
||||
|
||||
user = models.ForeignKey(
|
||||
"users.User",
|
||||
settings.AUTH_USER_MODEL,
|
||||
on_delete=models.CASCADE,
|
||||
related_name="reading_progress",
|
||||
related_name="book_reading_progress",
|
||||
db_index=True,
|
||||
)
|
||||
book = models.ForeignKey(
|
||||
Book,
|
||||
on_delete=models.CASCADE,
|
||||
related_name="reading_progress",
|
||||
related_name="book_reading_progress",
|
||||
db_index=True,
|
||||
)
|
||||
current_chapter = models.PositiveIntegerField(default=1)
|
||||
@@ -73,16 +243,16 @@ class ReadingProgress(models.Model):
|
||||
updated_at = models.DateTimeField(auto_now=True)
|
||||
|
||||
class Meta:
|
||||
db_table = "books_reading_progress"
|
||||
verbose_name = "Reading Progress"
|
||||
verbose_name_plural = "Reading Progress"
|
||||
db_table = "books_book_reading_progress"
|
||||
verbose_name = "Book Reading Progress"
|
||||
verbose_name_plural = "Book Reading Progress"
|
||||
ordering = ["-updated_at"]
|
||||
constraints = [
|
||||
models.UniqueConstraint(
|
||||
fields=["user", "book"],
|
||||
name="uq_reading_progress_user_book",
|
||||
name="uq_book_reading_progress_user_book",
|
||||
)
|
||||
]
|
||||
|
||||
def __str__(self) -> str:
|
||||
def __str__(self):
|
||||
return f"{self.user} — {self.book.title} ({self.percentage:.0f}%)"
|
||||
@@ -1,31 +1,192 @@
|
||||
from rest_framework import serializers
|
||||
|
||||
from apps.books.models import Book, Chapter, ReadingProgress
|
||||
from apps.books.models import Book, BookChapter, BookReadingProgress, Chapter, EBook, FontStyle, BackgroundColor, ReadingProgress, ReadingSettings, ReadingStatus, DownloadRecord
|
||||
|
||||
|
||||
class BookSerializer(serializers.ModelSerializer):
|
||||
"""Serialize Book data."""
|
||||
|
||||
class BookChapterSerializer(serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = Book
|
||||
fields = [
|
||||
"id",
|
||||
"title",
|
||||
"author",
|
||||
"total_pages",
|
||||
"cover_image",
|
||||
"created_at",
|
||||
"updated_at",
|
||||
]
|
||||
read_only_fields = ["id", "created_at", "updated_at"]
|
||||
model = BookChapter
|
||||
fields = ["id", "title", "index", "href", "children"]
|
||||
|
||||
|
||||
class EBookContentSerializer(serializers.Serializer):
|
||||
page = serializers.IntegerField()
|
||||
total_pages = serializers.IntegerField()
|
||||
content = serializers.CharField()
|
||||
chapter_title = serializers.CharField()
|
||||
format = serializers.CharField()
|
||||
|
||||
|
||||
class EBookTocSerializer(serializers.Serializer):
|
||||
chapters = serializers.ListField(child=BookChapterSerializer())
|
||||
format = serializers.CharField()
|
||||
page_count = serializers.IntegerField()
|
||||
|
||||
|
||||
class BookListSerializer(serializers.ModelSerializer):
|
||||
"""Lightweight serializer for list views (excludes heavy fields)."""
|
||||
reading_status_display = serializers.CharField(source="get_reading_status_display", read_only=True)
|
||||
|
||||
class Meta:
|
||||
model = Book
|
||||
fields = ["id", "title", "author", "total_pages", "cover_image"]
|
||||
fields = ["id", "title", "author", "genre", "reading_status", "reading_status_display", "cover_image"]
|
||||
|
||||
|
||||
class BookDetailSerializer(serializers.ModelSerializer):
|
||||
reading_status_display = serializers.CharField(source="get_reading_status_display", read_only=True)
|
||||
|
||||
class Meta:
|
||||
model = Book
|
||||
fields = ["id", "title", "author", "genre", "description", "reading_status", "reading_status_display", "cover_image", "total_pages", "created_at", "updated_at"]
|
||||
read_only_fields = ["id", "created_at", "updated_at"]
|
||||
|
||||
|
||||
class BookSerializer(serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = Book
|
||||
fields = ["id", "title", "author", "genre", "description", "reading_status", "cover_image", "total_pages", "created_at", "updated_at"]
|
||||
read_only_fields = ["id", "created_at", "updated_at"]
|
||||
|
||||
|
||||
class EBookListSerializer(serializers.ModelSerializer):
|
||||
filename = serializers.CharField(read_only=True)
|
||||
format = serializers.CharField(read_only=True)
|
||||
progress = serializers.SerializerMethodField()
|
||||
|
||||
class Meta:
|
||||
model = EBook
|
||||
fields = ["id", "title", "author", "filename", "format", "page_count", "file_size", "cover_image", "created_at", "progress"]
|
||||
|
||||
def get_progress(self, obj):
|
||||
try:
|
||||
return obj.reading_progress.current_position
|
||||
except ReadingProgress.DoesNotExist:
|
||||
return None
|
||||
|
||||
|
||||
class EBookDetailSerializer(serializers.ModelSerializer):
|
||||
filename = serializers.CharField(read_only=True)
|
||||
format = serializers.CharField(read_only=True)
|
||||
file_url = serializers.SerializerMethodField()
|
||||
progress = serializers.SerializerMethodField()
|
||||
|
||||
class Meta:
|
||||
model = EBook
|
||||
fields = ["id", "title", "author", "filename", "format", "page_count", "file_size", "file_url", "cover_image", "created_at", "updated_at", "progress"]
|
||||
|
||||
def get_file_url(self, obj):
|
||||
request = self.context.get("request")
|
||||
if request and obj.file:
|
||||
return request.build_absolute_uri(obj.file.url)
|
||||
return ""
|
||||
|
||||
def get_progress(self, obj):
|
||||
try:
|
||||
rp = obj.reading_progress
|
||||
return {"current_position": rp.current_position, "last_page": rp.last_page}
|
||||
except ReadingProgress.DoesNotExist:
|
||||
return None
|
||||
|
||||
|
||||
class EBookUploadSerializer(serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = EBook
|
||||
fields = ["title", "author", "file", "cover_image"]
|
||||
extra_kwargs = {"title": {"required": True}, "file": {"required": True}}
|
||||
|
||||
def validate_file(self, value):
|
||||
import os
|
||||
if value is None:
|
||||
return value
|
||||
ext = os.path.splitext(str(getattr(value, "name", "")))[1].lower()
|
||||
if ext not in (".epub", ".pdf"):
|
||||
raise serializers.ValidationError("Only EPUB and PDF files are supported.")
|
||||
return value
|
||||
|
||||
def create(self, validated_data):
|
||||
validated_data["user"] = self.context["request"].user
|
||||
# Auto-detect format from file extension
|
||||
import os
|
||||
name = str(getattr(validated_data.get("file"), "name", ""))
|
||||
ext = os.path.splitext(name)[1].lower().lstrip(".")
|
||||
if ext:
|
||||
validated_data["format"] = ext
|
||||
return super().create(validated_data)
|
||||
|
||||
|
||||
class ReadingProgressSerializer(serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = ReadingProgress
|
||||
fields = ["current_position", "last_page", "device_id", "device_name", "version", "updated_at"]
|
||||
read_only_fields = ["version", "updated_at"]
|
||||
extra_kwargs = {"current_position": {"required": True, "min_value": 0.0, "max_value": 100.0}}
|
||||
|
||||
def validate_current_position(self, value):
|
||||
if value < 0.0 or value > 100.0:
|
||||
raise serializers.ValidationError("Position must be between 0.0 and 100.0.")
|
||||
return value
|
||||
|
||||
|
||||
class ReadingSettingsSerializer(serializers.ModelSerializer):
|
||||
class Meta:
|
||||
model = ReadingSettings
|
||||
fields = ["font_size", "font_style", "background_color"]
|
||||
|
||||
def validate_font_size(self, value):
|
||||
if value < 12 or value > 36:
|
||||
raise serializers.ValidationError("Font size must be between 12 and 36.")
|
||||
return value
|
||||
|
||||
def validate_font_style(self, value):
|
||||
valid = [s.value for s in FontStyle]
|
||||
if value not in valid:
|
||||
raise serializers.ValidationError(f"Font style must be one of: {', '.join(valid)}")
|
||||
return value
|
||||
|
||||
def validate_background_color(self, value):
|
||||
valid = [c.value for c in BackgroundColor]
|
||||
if value not in valid:
|
||||
raise serializers.ValidationError(f"Background color must be one of: {', '.join(valid)}")
|
||||
return value
|
||||
|
||||
|
||||
class DownloadRecordSerializer(serializers.ModelSerializer):
|
||||
ebook_id = serializers.IntegerField(source="ebook.id", read_only=True)
|
||||
ebook_title = serializers.CharField(source="ebook.title", read_only=True)
|
||||
author = serializers.CharField(source="ebook.author", read_only=True)
|
||||
filename = serializers.SerializerMethodField()
|
||||
cover_image = serializers.ImageField(source="ebook.cover_image", read_only=True)
|
||||
format = serializers.CharField(source="ebook.format", read_only=True)
|
||||
progress = serializers.SerializerMethodField()
|
||||
file_url = serializers.SerializerMethodField()
|
||||
|
||||
class Meta:
|
||||
model = DownloadRecord
|
||||
fields = [
|
||||
"id", "ebook_id", "ebook_title", "author", "filename", "file_url",
|
||||
"file_size", "cover_image", "format", "downloaded_at", "progress",
|
||||
]
|
||||
|
||||
def get_filename(self, obj):
|
||||
return obj.ebook.filename()
|
||||
|
||||
def get_file_url(self, obj):
|
||||
request = self.context.get("request")
|
||||
if request and obj.ebook.file:
|
||||
return request.build_absolute_uri(obj.ebook.file.url)
|
||||
return ""
|
||||
|
||||
def get_progress(self, obj):
|
||||
try:
|
||||
rp = obj.ebook.reading_progress
|
||||
return {"current_position": rp.current_position, "last_page": rp.last_page}
|
||||
except ReadingProgress.DoesNotExist:
|
||||
return None
|
||||
|
||||
|
||||
class StorageSummarySerializer(serializers.Serializer):
|
||||
total_downloads = serializers.IntegerField()
|
||||
total_size_bytes = serializers.IntegerField()
|
||||
ebooks = serializers.ListField(child=serializers.DictField())
|
||||
|
||||
|
||||
class ChapterSummarySerializer(serializers.ModelSerializer):
|
||||
@@ -45,27 +206,23 @@ class ChapterDetailSerializer(serializers.ModelSerializer):
|
||||
read_only_fields = ["id", "created_at", "updated_at"]
|
||||
|
||||
|
||||
class ReadingProgressSerializer(serializers.ModelSerializer):
|
||||
"""Serialize reading progress for a book."""
|
||||
class BookReadingProgressSerializer(serializers.ModelSerializer):
|
||||
"""Serialize chapter-based reading progress for a book."""
|
||||
|
||||
class Meta:
|
||||
model = ReadingProgress
|
||||
model = BookReadingProgress
|
||||
fields = [
|
||||
"id",
|
||||
"book",
|
||||
"current_chapter",
|
||||
"current_position",
|
||||
"percentage",
|
||||
"updated_at",
|
||||
"id", "book", "current_chapter", "current_position",
|
||||
"percentage", "updated_at",
|
||||
]
|
||||
read_only_fields = ["id", "updated_at"]
|
||||
|
||||
def validate_percentage(self, value: float) -> float:
|
||||
def validate_percentage(self, value):
|
||||
if value < 0.0 or value > 100.0:
|
||||
raise serializers.ValidationError("Percentage must be between 0 and 100.")
|
||||
return value
|
||||
|
||||
def validate_current_chapter(self, value: int) -> int:
|
||||
def validate_current_chapter(self, value):
|
||||
if value < 1:
|
||||
raise serializers.ValidationError("Chapter number must be positive.")
|
||||
return value
|
||||
+293
-27
@@ -1,53 +1,94 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import Any
|
||||
|
||||
from django.db.models import QuerySet, Q
|
||||
from django_filters.rest_framework import DjangoFilterBackend
|
||||
from rest_framework import status, viewsets
|
||||
from rest_framework import parsers, permissions, status, viewsets
|
||||
from rest_framework.decorators import action
|
||||
from rest_framework.filters import OrderingFilter, SearchFilter
|
||||
from rest_framework.permissions import IsAuthenticated
|
||||
from rest_framework.permissions import AllowAny, IsAuthenticated
|
||||
from rest_framework.request import Request
|
||||
from rest_framework.response import Response
|
||||
|
||||
from apps.books.models import Book, Chapter, ReadingProgress
|
||||
from apps.books.models import Book, BookChapter, BookReadingProgress, DownloadRecord, EBook, Chapter, ReadingProgress, ReadingSettings
|
||||
from apps.books.serializers import (
|
||||
BookListSerializer,
|
||||
BookSerializer,
|
||||
ChapterDetailSerializer,
|
||||
ChapterSummarySerializer,
|
||||
ReadingProgressSerializer,
|
||||
BookChapterSerializer, BookDetailSerializer, BookListSerializer, BookSerializer,
|
||||
BookReadingProgressSerializer, ChapterDetailSerializer, ChapterSummarySerializer,
|
||||
DownloadRecordSerializer, EBookContentSerializer, EBookDetailSerializer,
|
||||
EBookListSerializer, EBookTocSerializer, EBookUploadSerializer,
|
||||
ReadingProgressSerializer, ReadingSettingsSerializer, StorageSummarySerializer,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class BookViewSet(viewsets.ModelViewSet):
|
||||
"""CRUD for books. Includes nested chapter and progress endpoints."""
|
||||
|
||||
queryset = Book.objects.all().prefetch_related("chapters")
|
||||
queryset = Book.objects.all()
|
||||
permission_classes = [IsAuthenticated]
|
||||
filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
|
||||
filterset_fields = ["author"]
|
||||
search_fields = ["title", "author"]
|
||||
ordering_fields = ["title", "author", "created_at"]
|
||||
filterset_fields = ["author", "genre", "reading_status"]
|
||||
search_fields = ["title", "author", "genre"]
|
||||
ordering_fields = ["title", "author", "genre", "created_at"]
|
||||
ordering = ["title"]
|
||||
|
||||
def get_serializer_class(self):
|
||||
if self.action == "retrieve":
|
||||
return BookDetailSerializer
|
||||
if self.action == "list":
|
||||
return BookListSerializer
|
||||
return BookSerializer
|
||||
|
||||
def get_queryset(self) -> QuerySet[Book]:
|
||||
qs = super().get_queryset()
|
||||
query = self.request.query_params.get("q", "").strip()
|
||||
if query:
|
||||
qs = qs.filter(Q(title__icontains=query) | Q(author__icontains=query) | Q(genre__icontains=query))
|
||||
return qs
|
||||
|
||||
@action(detail=False, methods=["get"], permission_classes=[AllowAny])
|
||||
def genres(self, request: Request) -> Response:
|
||||
genre_list = Book.objects.values_list("genre", flat=True).distinct().order_by("genre")
|
||||
return Response([g for g in genre_list if g])
|
||||
|
||||
@action(detail=False, methods=["get"], permission_classes=[AllowAny])
|
||||
def authors(self, request: Request) -> Response:
|
||||
author_list = Book.objects.values_list("author", flat=True).distinct().order_by("author")
|
||||
return Response([a for a in author_list if a])
|
||||
|
||||
@action(detail=False, methods=["get"])
|
||||
def storage(self, request: Request) -> Response:
|
||||
"""Return storage usage summary for the current user."""
|
||||
download_records = DownloadRecord.objects.filter(user=request.user).select_related("ebook")
|
||||
total_size = sum(r.file_size for r in download_records)
|
||||
ebook_list = [
|
||||
{"id": r.ebook.id, "title": r.ebook.title, "file_size": r.file_size}
|
||||
for r in download_records
|
||||
]
|
||||
serializer = StorageSummarySerializer(data={
|
||||
"total_downloads": download_records.count(),
|
||||
"total_size_bytes": total_size,
|
||||
"ebooks": ebook_list,
|
||||
})
|
||||
serializer.is_valid(raise_exception=True)
|
||||
return Response(serializer.data)
|
||||
|
||||
|
||||
@action(detail=True, methods=["get"])
|
||||
def chapters(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""List all chapters for this book (TOC)."""
|
||||
book = self.get_object()
|
||||
chapters = book.chapters.all().order_by("number")
|
||||
serializer = ChapterSummarySerializer(chapters, many=True)
|
||||
chapter_qs = Chapter.objects.filter(book=book).order_by("number")
|
||||
serializer = ChapterSummarySerializer(chapter_qs, many=True)
|
||||
return Response(serializer.data)
|
||||
|
||||
@action(detail=True, methods=["get"], url_path="chapters/(?P<chapter_number>[0-9]+)")
|
||||
def chapter_detail(
|
||||
self, request: Request, pk: int | None = None, chapter_number: str | None = None
|
||||
) -> Response:
|
||||
@action(detail=True, methods=["get"], url_path=r"chapters/(?P<chapter_number>[0-9]+)")
|
||||
def chapter_detail(self, request: Request, pk: int | None = None, chapter_number: str | None = None) -> Response:
|
||||
"""Get a specific chapter with full content."""
|
||||
book = self.get_object()
|
||||
try:
|
||||
chapter = book.chapters.get(number=int(chapter_number))
|
||||
chapter = Chapter.objects.get(book=book, number=int(chapter_number or "0"))
|
||||
except Chapter.DoesNotExist:
|
||||
return Response(
|
||||
{"detail": "Chapter not found."}, status=status.HTTP_404_NOT_FOUND
|
||||
@@ -57,19 +98,244 @@ class BookViewSet(viewsets.ModelViewSet):
|
||||
|
||||
@action(detail=True, methods=["get", "put"])
|
||||
def progress(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""Get or update reading progress for this book."""
|
||||
"""Get or update chapter-based reading progress for this book."""
|
||||
book = self.get_object()
|
||||
progress, created = ReadingProgress.objects.get_or_create(
|
||||
progress_obj, _created = BookReadingProgress.objects.get_or_create(
|
||||
user=request.user, book=book
|
||||
)
|
||||
|
||||
if request.method == "GET":
|
||||
serializer = ReadingProgressSerializer(progress)
|
||||
serializer = BookReadingProgressSerializer(progress_obj)
|
||||
return Response(serializer.data)
|
||||
|
||||
serializer = ReadingProgressSerializer(
|
||||
progress, data=request.data, partial=True
|
||||
serializer = BookReadingProgressSerializer(
|
||||
progress_obj, data=request.data, partial=True
|
||||
)
|
||||
serializer.is_valid(raise_exception=True)
|
||||
serializer.save()
|
||||
return Response(serializer.data, status=status.HTTP_200_OK)
|
||||
return Response(serializer.data, status=status.HTTP_200_OK)
|
||||
|
||||
|
||||
class IsEBookOwner(permissions.BasePermission):
|
||||
def has_object_permission(self, request: Request, view: object, obj: EBook) -> bool:
|
||||
return obj.user == request.user
|
||||
|
||||
|
||||
class EBookViewSet(viewsets.ModelViewSet):
|
||||
parser_classes = [parsers.MultiPartParser, parsers.FormParser, parsers.JSONParser]
|
||||
permission_classes = [IsAuthenticated, IsEBookOwner]
|
||||
|
||||
def get_serializer_class(self):
|
||||
if self.action == "create":
|
||||
return EBookUploadSerializer
|
||||
if self.action in ("list",):
|
||||
return EBookListSerializer
|
||||
if self.action in ("toc",):
|
||||
return BookChapterSerializer
|
||||
return EBookDetailSerializer
|
||||
|
||||
def get_queryset(self):
|
||||
return EBook.objects.filter(user=self.request.user).select_related("reading_progress", "user")
|
||||
|
||||
@action(detail=True, methods=["get", "patch"])
|
||||
def progress(self, request: Request, pk: int | None = None) -> Response:
|
||||
ebook = self.get_object()
|
||||
progress_obj, _created = ReadingProgress.objects.get_or_create(user=request.user, ebook=ebook)
|
||||
if request.method == "GET":
|
||||
serializer = ReadingProgressSerializer(progress_obj)
|
||||
return Response(serializer.data)
|
||||
serializer = ReadingProgressSerializer(progress_obj, data=request.data, partial=True)
|
||||
serializer.is_valid(raise_exception=True)
|
||||
serializer.save()
|
||||
return Response(serializer.data)
|
||||
|
||||
@action(detail=True, methods=["post"])
|
||||
def process(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""Trigger e-book processing: metadata extraction, TOC building, page counting."""
|
||||
ebook = self.get_object()
|
||||
if not ebook.file:
|
||||
return Response({"error": "No file found for this e-book."}, status=status.HTTP_400_BAD_REQUEST)
|
||||
|
||||
try:
|
||||
from apps.books.services import process_ebook
|
||||
|
||||
file_path = ebook.file.path
|
||||
result = process_ebook(file_path, original_filename=ebook.filename())
|
||||
|
||||
# Update ebook with extracted data
|
||||
ebook.format = result.get("format", ebook.format)
|
||||
ebook.page_count = result.get("page_count", 0)
|
||||
ebook.metadata_json = result.get("metadata", {})
|
||||
ebook.save(update_fields=["format", "page_count", "metadata_json", "updated_at"])
|
||||
|
||||
# Store chapters in DB
|
||||
raw_toc: list[dict[str, Any]] = result.get("toc", [])
|
||||
BookChapter.objects.filter(ebook=ebook).delete()
|
||||
_store_chapters(ebook, raw_toc)
|
||||
|
||||
return Response({
|
||||
"format": ebook.format,
|
||||
"page_count": ebook.page_count,
|
||||
"metadata": ebook.metadata_json,
|
||||
"toc_count": len(raw_toc),
|
||||
"status": "processed",
|
||||
})
|
||||
except Exception as exc:
|
||||
logger.exception("Failed to process ebook %s", ebook.id)
|
||||
return Response({"error": f"Processing failed: {exc}"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||||
|
||||
@action(detail=True, methods=["get"])
|
||||
def toc(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""Return hierarchical table of contents."""
|
||||
ebook = self.get_object()
|
||||
chapters = BookChapter.objects.filter(ebook=ebook).order_by("index").select_related("ebook")
|
||||
serializer = BookChapterSerializer(chapters, many=True)
|
||||
return Response({
|
||||
"chapters": serializer.data,
|
||||
"format": ebook.format,
|
||||
"page_count": ebook.page_count,
|
||||
})
|
||||
|
||||
@action(detail=True, methods=["get"])
|
||||
def content(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""Return paginated content for a given page number.
|
||||
|
||||
Query params:
|
||||
page (int): page/chapter index to fetch (1-indexed, default: 1)
|
||||
"""
|
||||
ebook = self.get_object()
|
||||
page = max(1, int(request.query_params.get("page", 1)))
|
||||
|
||||
chapters = list(BookChapter.objects.filter(ebook=ebook).order_by("index").select_related("ebook"))
|
||||
total_pages = len(chapters) or ebook.page_count or 1
|
||||
|
||||
chapter: BookChapter | None = None
|
||||
chapter_title = ""
|
||||
content_html = ""
|
||||
|
||||
if chapters and 0 <= page - 1 < len(chapters):
|
||||
ch = chapters[page - 1]
|
||||
chapter_title = ch.title
|
||||
content_html = _fetch_chapter_content(ebook, ch)
|
||||
|
||||
serializer = EBookContentSerializer(data={
|
||||
"page": page,
|
||||
"total_pages": total_pages,
|
||||
"content": content_html,
|
||||
"chapter_title": chapter_title,
|
||||
"format": ebook.format,
|
||||
})
|
||||
serializer.is_valid(raise_exception=True)
|
||||
return Response(serializer.data)
|
||||
|
||||
@action(detail=True, methods=["post"])
|
||||
def download(self, request: Request, pk: int | None = None) -> Response:
|
||||
"""Track download of an e-book. Creates a DownloadRecord and returns file info."""
|
||||
ebook = self.get_object()
|
||||
if not ebook.file:
|
||||
return Response({"error": "No file found for this e-book."}, status=status.HTTP_400_BAD_REQUEST)
|
||||
|
||||
download, created = DownloadRecord.objects.get_or_create(
|
||||
user=request.user,
|
||||
ebook=ebook,
|
||||
defaults={"file_size": ebook.file.size if ebook.file else 0},
|
||||
)
|
||||
if not created:
|
||||
download.file_size = ebook.file.size if ebook.file else 0
|
||||
download.save(update_fields=["file_size"])
|
||||
|
||||
serializer = DownloadRecordSerializer(download, context={"request": request})
|
||||
return Response(serializer.data, status=status.HTTP_200_OK)
|
||||
|
||||
@action(detail=False, methods=["get"])
|
||||
def downloads(self, request: Request) -> Response:
|
||||
"""List all e-books the current user has downloaded."""
|
||||
records = DownloadRecord.objects.filter(user=request.user).select_related(
|
||||
"ebook", "ebook__reading_progress"
|
||||
).prefetch_related("ebook__chapters")
|
||||
page = self.paginate_queryset(records)
|
||||
if page is not None:
|
||||
serializer = DownloadRecordSerializer(page, many=True, context={"request": request})
|
||||
return self.get_paginated_response(serializer.data)
|
||||
serializer = DownloadRecordSerializer(records, many=True, context={"request": request})
|
||||
return Response(serializer.data)
|
||||
|
||||
@action(detail=False, methods=["delete"], url_path="downloads/(?P<download_pk>[^/.]+)")
|
||||
def delete_download(self, request: Request, download_pk: str | None = None) -> Response:
|
||||
"""Delete a download record."""
|
||||
try:
|
||||
download = DownloadRecord.objects.get(pk=download_pk, user=request.user)
|
||||
except DownloadRecord.DoesNotExist:
|
||||
return Response({"error": "Download record not found."}, status=status.HTTP_404_NOT_FOUND)
|
||||
download.delete()
|
||||
return Response(status=status.HTTP_204_NO_CONTENT)
|
||||
|
||||
|
||||
def _store_chapters(ebook: EBook, toc: list[dict[str, Any]], parent_index: int = 0) -> None:
|
||||
"""Recursively store TOC entries as BookChapter records."""
|
||||
for idx, entry in enumerate(toc):
|
||||
BookChapter.objects.create(
|
||||
ebook=ebook,
|
||||
title=entry.get("title", "Untitled"),
|
||||
index=parent_index + idx,
|
||||
href=entry.get("href", ""),
|
||||
children=entry.get("children", []),
|
||||
)
|
||||
children = entry.get("children", [])
|
||||
if children:
|
||||
_store_chapters(ebook, children, parent_index + idx + 1)
|
||||
|
||||
|
||||
def _fetch_chapter_content(ebook: EBook, chapter: BookChapter) -> str:
|
||||
"""Fetch HTML content for a chapter from the e-book file."""
|
||||
if ebook.format == "epub":
|
||||
return _fetch_epub_chapter_content(ebook.file.path, chapter)
|
||||
return ""
|
||||
|
||||
|
||||
def _fetch_epub_chapter_content(file_path: str, chapter: BookChapter) -> str:
|
||||
"""Extract HTML content of a specific EPUB chapter by href."""
|
||||
try:
|
||||
from ebooklib import epub
|
||||
from bs4 import BeautifulSoup
|
||||
except ImportError:
|
||||
return ""
|
||||
|
||||
try:
|
||||
book = epub.read_epub(file_path)
|
||||
href = chapter.href or ""
|
||||
# Find the item by href
|
||||
for item in book.get_items():
|
||||
item_name = item.get_name() or ""
|
||||
if href and (item_name.endswith(href) or href.endswith(item_name)):
|
||||
content = item.get_content()
|
||||
soup = BeautifulSoup(content, "html.parser")
|
||||
# Clean up — remove body/html/head wrappers, keep inner content
|
||||
body = soup.find("body")
|
||||
if body:
|
||||
return str(body)
|
||||
return str(soup)
|
||||
return ""
|
||||
except Exception:
|
||||
logger.exception("Failed to fetch EPUB chapter content for %s", chapter.href)
|
||||
return ""
|
||||
|
||||
|
||||
class ReadingSettingsViewSet(viewsets.GenericViewSet):
|
||||
permission_classes = [IsAuthenticated]
|
||||
serializer_class = ReadingSettingsSerializer
|
||||
|
||||
def get_queryset(self):
|
||||
return ReadingSettings.objects.filter(user=self.request.user)
|
||||
|
||||
def list(self, request: Request) -> Response:
|
||||
settings_obj, _created = ReadingSettings.objects.get_or_create(user=request.user)
|
||||
serializer = self.get_serializer(settings_obj)
|
||||
return Response(serializer.data)
|
||||
|
||||
def partial_update(self, request: Request) -> Response:
|
||||
settings_obj, _created = ReadingSettings.objects.get_or_create(user=request.user)
|
||||
serializer = self.get_serializer(settings_obj, data=request.data, partial=True)
|
||||
serializer.is_valid(raise_exception=True)
|
||||
serializer.save()
|
||||
return Response(serializer.data)
|
||||
Reference in New Issue
Block a user