# Copyright © Fundacja Wolne Lektury. See NOTICE for more information.
#
from datetime import datetime
-from pytz import utc
+from django.db.models import Q
from django.http import Http404
-from django.utils.timezone import now
+from django.utils.timezone import now, utc
from rest_framework.generics import ListAPIView, ListCreateAPIView, RetrieveAPIView, RetrieveUpdateAPIView, RetrieveUpdateDestroyAPIView, get_object_or_404
-from rest_framework.permissions import IsAuthenticated, IsAuthenticatedOrReadOnly
+from rest_framework.permissions import SAFE_METHODS, IsAuthenticated, IsAuthenticatedOrReadOnly
from rest_framework.response import Response
from rest_framework import serializers
from rest_framework.views import APIView
from catalogue.models import Book
import catalogue.models
from social.views import get_sets_for_book_ids
+from social.utils import likes
from social import models
+import bookmarks.models
+from bookmarks.api.views import BookmarkSerializer
+
+
+class SettingsSerializer(serializers.ModelSerializer):
+ class Meta:
+ model = models.UserProfile
+ fields = ['notifications']
+
+
+class SettingsView(RetrieveUpdateAPIView):
+ permission_classes = [IsAuthenticated]
+ serializer_class = SettingsSerializer
+
+ def get_object(self):
+ return models.UserProfile.get_for(self.request.user)
@never_cache
class UserListSerializer(serializers.ModelSerializer):
- books = UserListItemsField(source='*')
+ client_id = serializers.CharField(write_only=True, required=False)
+ books = UserListItemsField(source='*', required=False)
+ timestamp = serializers.IntegerField(required=False)
class Meta:
model = models.UserList
- fields = ['name', 'slug', 'books']
- read_only_fields = ['slug']
+ fields = [
+ 'timestamp',
+ 'client_id',
+ 'name',
+ 'slug',
+ 'favorites',
+ 'deleted',
+ 'books',
+ ]
+ read_only_fields = ['favorites']
+ extra_kwargs = {
+ 'slug': {
+ 'required': False
+ }
+ }
def create(self, validated_data):
instance = models.UserList.get_by_name(
fields = ['books']
+class UserListItemSerializer(serializers.ModelSerializer):
+ client_id = serializers.CharField(write_only=True, required=False)
+ favorites = serializers.BooleanField(required=False)
+ list_slug = serializers.SlugRelatedField(
+ queryset=models.UserList.objects.all(),
+ source='list',
+ slug_field='slug',
+ required=False,
+ )
+ timestamp = serializers.IntegerField(required=False)
+ book_slug = serializers.SlugRelatedField(
+ queryset=Book.objects.all(),
+ source='book',
+ slug_field='slug',
+ required=False
+ )
+
+ class Meta:
+ model = models.UserListItem
+ fields = [
+ 'client_id',
+ 'uuid',
+ 'order',
+ 'list_slug',
+ 'timestamp',
+ 'favorites',
+ 'deleted',
+
+ 'book_slug',
+ 'fragment',
+ 'quote',
+ 'bookmark',
+ 'note',
+ ]
+ extra_kwargs = {
+ 'order': {
+ 'required': False
+ }
+ }
+
+
@never_cache
class ListsView(ListCreateAPIView):
permission_classes = [IsAuthenticated]
@never_cache
class ListView(RetrieveUpdateDestroyAPIView):
# TODO: check if can modify
- permission_classes = [IsAuthenticated]
+ permission_classes = [IsAuthenticatedOrReadOnly]
serializer_class = UserListSerializer
def get_object(self):
- return get_object_or_404(
- models.UserList,
- slug=self.kwargs['slug'],
- user=self.request.user)
+ if self.request.method in SAFE_METHODS:
+ q = Q(deleted=False)
+ if self.request.user.is_authenticated:
+ q |= Q(user=self.request.user)
+ return get_object_or_404(
+ models.UserList,
+ q,
+ slug=self.kwargs['slug'],
+ )
+ else:
+ return get_object_or_404(
+ models.UserList,
+ slug=self.kwargs['slug'],
+ user=self.request.user)
def perform_update(self, serializer):
serializer.save(user=self.request.user)
return Response(self.get_serializer(instance).data)
def perform_destroy(self, instance):
- instance.update(
- deleted=True,
- updated_at=now()
- )
+ instance.deleted = True
+ instance.updated_at = now()
+ instance.save()
@never_cache
view_name='catalogue_api_book',
lookup_field='slug'
)
- book_slug = serializers.SlugRelatedField(source='book', read_only=True, slug_field='slug')
+ book_slug = serializers.SlugRelatedField(
+ queryset=Book.objects.all(),
+ source='book',
+ slug_field='slug')
+ timestamp = serializers.IntegerField(required=False)
class Meta:
model = models.Progress
- fields = ['book', 'book_slug', 'last_mode', 'text_percent',
- 'text_anchor',
- 'audio_percent',
- 'audio_timestamp',
- 'implicit_text_percent',
- 'implicit_text_anchor',
- 'implicit_audio_percent',
- 'implicit_audio_timestamp',
- ]
+ fields = [
+ 'timestamp',
+ 'book', 'book_slug', 'last_mode', 'text_percent',
+ 'text_anchor',
+ 'audio_percent',
+ 'audio_timestamp',
+ 'implicit_text_percent',
+ 'implicit_text_anchor',
+ 'implicit_audio_percent',
+ 'implicit_audio_timestamp',
+ ]
+ extra_kwargs = {
+ 'last_mode': {
+ 'required': False,
+ 'default': 'text',
+ }
+ }
class TextProgressSerializer(serializers.ModelSerializer):
-class SyncSerializer(serializers.Serializer):
- timestamp = serializers.IntegerField()
- type = serializers.CharField()
- id = serializers.CharField()
-
- def to_representation(self, instance):
- rep = super().to_representation(instance)
- rep['object'] = instance['object'].data
- return rep
-
- def to_internal_value(self, data):
- ret = super().to_internal_value(data)
- ret['object'] = data['object']
- return ret
-
-
@never_cache
class SyncView(ListAPIView):
permission_classes = [IsAuthenticated]
- serializer_class = SyncSerializer
+ sync_id_field = 'slug'
+ sync_id_serializer_field = 'slug'
+ sync_user_field = 'user'
def get_queryset(self):
try:
timestamp = datetime.fromtimestamp(timestamp, tz=utc)
data = []
- for p in models.Progress.objects.filter(
- user=self.request.user,
- updated_at__gt=timestamp).order_by('updated_at'):
- data.append({
- 'timestamp': p.updated_at.timestamp(),
- 'type': 'progress',
- 'id': p.book.slug,
- 'object': ProgressSerializer(
- p, context={'request': self.request}
- ) if not p.deleted else None
- })
-
- for p in models.UserList.objects.filter(
- user=self.request.user,
- updated_at__gt=timestamp).order_by('updated_at'):
- data.append({
- 'timestamp': p.updated_at.timestamp(),
- 'type': 'user-list',
- 'id': p.slug,
- 'object': UserListSerializer(
- p, context={'request': self.request}
- ) if not p.deleted else None
- })
-
- data.sort(key=lambda x: x['timestamp'])
- return data
+ return self.get_queryset_for_ts(timestamp)
+
+ def get_queryset_for_ts(self, timestamp):
+ return self.model.objects.filter(
+ updated_at__gt=timestamp,
+ **{
+ self.sync_user_field: self.request.user
+ }
+ ).order_by('updated_at')
+
+ def get_instance(self, user, data):
+ sync_id = data.get(self.sync_id_serializer_field)
+ if not sync_id:
+ return None
+ return self.model.objects.filter(**{
+ self.sync_user_field: user,
+ self.sync_id_field: sync_id
+ }).first()
def post(self, request):
+ new_ids = []
data = request.data
+ if not isinstance(data, list):
+ raise serializers.ValidationError('Payload should be a list')
for item in data:
- ser = SyncSerializer(data=item)
+ instance = self.get_instance(request.user, item)
+ ser = self.get_serializer(
+ instance=instance,
+ data=item
+ )
ser.is_valid(raise_exception=True)
- d = ser.validated_data
- if d['type'] == 'progress':
- if d['object'] is not None:
- objser = ProgressSerializer(data=d['object'])
- objser.is_valid(raise_exception=True)
- models.Progress.sync(
- user=request.user,
- slug=d['id'],
- ts=datetime.fromtimestamp(d['timestamp'], tz=utc),
- data=d['object']
- )
- return Response()
+ synced_instance = self.model.sync(
+ request.user,
+ instance,
+ ser.validated_data
+ )
+ if instance is None and 'client_id' in ser.validated_data and synced_instance is not None:
+ new_ids.append({
+ 'client_id': ser.validated_data['client_id'],
+ self.sync_id_serializer_field: getattr(synced_instance, self.sync_id_field),
+ })
+ return Response(new_ids)
+
+
+class ProgressSyncView(SyncView):
+ model = models.Progress
+ serializer_class = ProgressSerializer
+
+ sync_id_field = 'book__slug'
+ sync_id_serializer_field = 'book_slug'
+
+
+class UserListSyncView(SyncView):
+ model = models.UserList
+ serializer_class = UserListSerializer
+
+
+class UserListItemSyncView(SyncView):
+ model = models.UserListItem
+ serializer_class = UserListItemSerializer
+
+ sync_id_field = 'uuid'
+ sync_id_serializer_field = 'uuid'
+ sync_user_field = 'list__user'
+
+ def get_queryset_for_ts(self, timestamp):
+ qs = self.model.objects.filter(
+ updated_at__gt=timestamp,
+ **{
+ self.sync_user_field: self.request.user
+ }
+ )
+ if self.request.query_params.get('favorites'):
+ qs = qs.filter(list__favorites=True)
+ return qs.order_by('updated_at')
+
+
+class BookmarkSyncView(SyncView):
+ model = bookmarks.models.Bookmark
+ serializer_class = BookmarkSerializer
+
+ sync_id_field = 'uuid'
+ sync_id_serializer_field = 'uuid'
+
+ def get_instance(self, user, data):
+ ret = super().get_instance(user, data)
+ if ret is None:
+ if data.get('location'):
+ ret = self.model.get_by_location(user, data['location'])
+ return ret
fnp / wolnelektury.git / blobdiff