api/views.py - master - applepie/movidex

api/views.py
212 строк7 KB
Кристина
first_commit
03 июн 2025, 18:20
03 июн 2025, 18:20d592765
from rest_framework import generics, permissions, viewsets, status
from rest_framework.decorators import action
from django.contrib.auth.models import User
from movieapp.models import Movie, WatchedMovie, Profile
from .serializers import UserWatchStatsSerializer, UserSearchSerializer, MovieSerializer, WatchedMovieSerializer
from django.shortcuts import get_object_or_404
from django.db.models import Q
from rest_framework.pagination import PageNumberPagination
from rest_framework.response import Response

# api/views.py
from rest_framework.decorators import api_view
from rest_framework import status
import json

# @api_view(['POST'])
# def save_movie(request):
#     try:
#         data = json.loads(request.body)
#         movie, created = Movie.objects.update_or_create(
#             tmdb_id=data["tmdb_id"],
#             is_Series=data["is_Series"],
#             defaults={
#                 "title": data["title"],
#                 "rating": data["rating"],
#                 "genre_ids": data["genre_ids"],
#                 "runtime": data["runtime"],
#                 "release_date": data["release_date"],
#                 "poster_path": data["poster_path"],
#                 "episode_count": data["episode_count"]
#             }
#         )
        
#         return Response(
#             {"status": "created" if created else "updated", "id": movie.id},
#             status=status.HTTP_201_CREATED
#         )
        
#     except Exception as e:
#         return Response(
#             {"error": str(e)},
#             status=status.HTTP_400_BAD_REQUEST
#         )

# @api_view(['GET'])
# def get_movie_status(request, tmdb_id):
#     try:
#         is_series = request.GET.get("is_series", "False") == "True"
#         movie = Movie.objects.get(tmdb_id=tmdb_id, is_Series=is_series)
        
#         is_watched = movie.users_watched.filter(id=request.user.id).exists()
#         is_liked = movie.users_like.filter(id=request.user.id).exists()
        
#         return Response({
#             "is_watched": is_watched,
#             "is_liked": is_liked
#         })
        
#     except Movie.DoesNotExist:
#         return Response(
#             {"error": "Movie not found"},
#             status=status.HTTP_404_NOT_FOUND
#         )

class UserWatchStatsView(generics.RetrieveAPIView):
    serializer_class = UserWatchStatsSerializer
    permission_classes = [permissions.AllowAny]
    queryset = User.objects.all()
    
    def get_object(self):
        user_id = self.kwargs.get('user_id')
        return get_object_or_404(User, pk=user_id)
    
class ProfileSearchView(generics.ListAPIView):
    pagination_class = PageNumberPagination
    page_size = 15
    serializer_class = UserSearchSerializer
    
    def get_queryset(self):
        query = self.request.query_params.get('q', '')
        if len(query) < 2:
            return Profile.objects.none()
        
        users = User.objects.filter(
            Q(username__icontains=query) |
            Q(first_name__icontains=query) |
            Q(last_name__icontains=query)
        )
        return users

class MovieViewSet(viewsets.ModelViewSet):
    queryset = Movie.objects.all()
    serializer_class = MovieSerializer
    
    
    @action(detail=True, methods=['post'])
    def add_to_watched(self, request, pk=None):
        movie = self.get_object()
        user = request.user
        
        if not user.is_authenticated:
            return Response({'status': 'not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
        
        WatchedMovie.objects.get_or_create(
            user=user,
            movie=movie,
            defaults={
                'episodes_watched': movie.episode_count
            }
        )
        
        return Response({'status': 'added to watched'})
    
    @action(detail=True, methods=['post'])
    def add_to_favorites(self, request, pk=None):
        movie = self.get_object()
        user = request.user
        
        if not user.is_authenticated:
            return Response({'status': 'not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
        
        movie.users_like.add(user)
        
        if not movie.users_watched.filter(id=user.id).exists():
            WatchedMovie.objects.create(
                user=user,
                movie=movie,
                episodes_watched=movie.episode_count
            )
        
        return Response({'status': 'added to favorites'})
    
    @action(detail=True, methods=['post'])
    def remove_from_favorites(self, request, pk=None):
        movie = self.get_object()
        user = request.user
        
        if not user.is_authenticated:
            return Response({'status': 'not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
        
        movie.users_like.remove(user)
        return Response({'status': 'removed from favorites'})
    
    @action(detail=True, methods=['delete'])
    def remove_from_watched(self, request, pk=None):
        movie = self.get_object()
        user = request.user
        
        if not user.is_authenticated:
            return Response({'status': 'not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
        
        WatchedMovie.objects.filter(user=user, movie=movie).delete()
        
        movie.users_like.remove(user)
        
        return Response({'status': 'removed from watched'})
    
    @action(detail=True, methods=['post'])
    def add_to_journal(self, request, pk=None):
        movie = self.get_object()
        user = request.user
        
        if not user.is_authenticated:
            return Response({'status': 'not authenticated'}, status=status.HTTP_401_UNAUTHORIZED)
        print(request.data)
        serializer = WatchedMovieSerializer(data=request.data, context={
            'request': request,
            'movie': movie
        })
        
        if not serializer.is_valid():
            return Response({
                'status': 'error',
                'errors': serializer.errors
            }, status=status.HTTP_400_BAD_REQUEST)
        
        try:
            serializer.save(user=user, movie=movie)
            
            return Response({
                'status': 'added to journal',
                'data': serializer.data
            })
            
        except Exception as e:
            return Response({
                'status': 'error',
                'message': str(e)
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

class JournalEntryViewSet(viewsets.ModelViewSet):
    queryset = WatchedMovie.objects.all()
    serializer_class = WatchedMovieSerializer
    
    def update(self, request, pk=None):
        entry = self.get_object()
        if entry.user != request.user:
            return Response({'status': 'forbidden'}, status=status.HTTP_403_FORBIDDEN)
        
        serializer = self.get_serializer(entry, data=request.data, partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        
        return Response(serializer.data)
    
    def destroy(self, request, pk=None):
        entry = self.get_object()
        if entry.user != request.user:
            return Response({'status': 'forbidden'}, status=status.HTTP_403_FORBIDDEN)
        
        entry.delete()
        return Response({'status': 'deleted'})