You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
311 lines
12 KiB
311 lines
12 KiB
from .serializers import ClubSerializer, CourtSerializer, DateIntervalSerializer, TournamentSerializer, UserSerializer, ChangePasswordSerializer, EventSerializer, RoundSerializer, GroupStageSerializer, MatchSerializer, TeamScoreSerializer, TeamRegistrationSerializer, PlayerRegistrationSerializer, LiveMatchSerializer, PurchaseSerializer, UserUpdateSerializer, FailedApiCallSerializer, LogSerializer, DeviceTokenSerializer
|
|
from tournaments.models import Club, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamScore, TeamRegistration, PlayerRegistration, Court, DateInterval, Purchase, FailedApiCall, Log, DeviceToken
|
|
|
|
from rest_framework import viewsets, permissions
|
|
from rest_framework.authtoken.models import Token
|
|
from rest_framework.response import Response
|
|
from rest_framework.decorators import api_view
|
|
from rest_framework import status
|
|
from rest_framework.generics import UpdateAPIView
|
|
from rest_framework.exceptions import MethodNotAllowed
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.views import APIView
|
|
|
|
from django.contrib.auth import authenticate
|
|
from django.db.models import Q
|
|
from django.core.exceptions import ObjectDoesNotExist
|
|
|
|
from .permissions import IsClubOwner
|
|
from .utils import is_valid_email
|
|
|
|
import tournaments.models
|
|
|
|
class CustomAuthToken(APIView):
|
|
permission_classes = []
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
username = request.data.get('username')
|
|
password = request.data.get('password')
|
|
device_id = request.data.get('device_id')
|
|
|
|
user = authenticate(username=username, password=password)
|
|
|
|
if user is None and is_valid_email(username) == True:
|
|
true_username = self.get_username_from_email(username)
|
|
user = authenticate(username=true_username, password=password)
|
|
|
|
if user is not None:
|
|
|
|
if user.device_id is None or user.device_id == device_id or user.username == 'apple-test':
|
|
user.device_id = device_id
|
|
user.save()
|
|
|
|
token, created = Token.objects.get_or_create(user=user)
|
|
return Response({'token': token.key})
|
|
else:
|
|
return Response({'error': 'Vous ne pouvez pour l\'instant vous connecter sur plusieurs appareils en même temps. Veuillez vous déconnecter du précédent appareil. Autrement, veuillez contacter le support.'}, status=status.HTTP_403_FORBIDDEN)
|
|
else:
|
|
return Response({'error': 'L\'utilisateur et le mot de passe de correspondent pas'}, status=status.HTTP_401_UNAUTHORIZED)
|
|
|
|
def get_username_from_email(self, email):
|
|
try:
|
|
user = CustomUser.objects.get(email=email)
|
|
return user.username
|
|
except ObjectDoesNotExist:
|
|
return None # or handle the case where the user doesn't exist
|
|
|
|
class Logout(APIView):
|
|
permission_classes = (IsAuthenticated,)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
request.user.auth_token.delete()
|
|
|
|
device_id = request.data.get('device_id')
|
|
if request.user.device_id == device_id:
|
|
request.user.device_id = None
|
|
request.user.save()
|
|
|
|
return Response(status=status.HTTP_200_OK)
|
|
|
|
class UserCanPayView(APIView):
|
|
permission_classes = (IsAuthenticated,)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
|
|
user = self.request.user
|
|
if user.is_anonymous:
|
|
return Response({'error': 'Vous n\'êtes pas authentifié'}, status=status.HTTP_401_UNAUTHORIZED)
|
|
|
|
club_id = request.data.get('club')
|
|
if club_id is None:
|
|
return Response({'error': 'Aucun club n\'est renseigné'}, status=status.HTTP_401_UNAUTHORIZED)
|
|
|
|
for club in user.authorized_clubs.all():
|
|
if club.id == club_id:
|
|
return Response({'payment': TournamentPayment.UNLIMITED}, status=status.HTTP_200_OK)
|
|
|
|
return Response(status=status.HTTP_401_UNAUTHORIZED) # request is fine but no payment returned
|
|
|
|
@api_view(['GET'])
|
|
def user_by_token(request):
|
|
serializer = UserSerializer(request.user)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
class UserViewSet(viewsets.ModelViewSet):
|
|
queryset = CustomUser.objects.all()
|
|
serializer_class = UserUpdateSerializer
|
|
permission_classes = [] # Users are public whereas the other requests are only for logged users
|
|
|
|
def get_serializer_class(self):
|
|
# Use UserSerializer for other actions (e.g., create, retrieve)
|
|
if self.action in ['create', 'retrieve']:
|
|
return UserSerializer
|
|
return self.serializer_class
|
|
|
|
class ChangePasswordView(UpdateAPIView):
|
|
serializer_class = ChangePasswordSerializer
|
|
|
|
def update(self, request, *args, **kwargs):
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
user = serializer.save()
|
|
# if using drf authtoken, create a new token
|
|
if hasattr(user, 'auth_token'):
|
|
user.auth_token.delete()
|
|
token, created = Token.objects.get_or_create(user=user)
|
|
# return new token
|
|
return Response({'token': token.key}, status=status.HTTP_200_OK)
|
|
|
|
class ClubViewSet(viewsets.ModelViewSet):
|
|
queryset = Club.objects.all()
|
|
serializer_class = ClubSerializer
|
|
permission_classes = [IsClubOwner] # Clubs are public whereas the other requests are only for logged users
|
|
|
|
def perform_create(self, serializer):
|
|
serializer.save(creator=self.request.user)
|
|
|
|
class EventViewSet(viewsets.ModelViewSet):
|
|
queryset = Event.objects.all()
|
|
serializer_class = EventSerializer
|
|
|
|
def get_queryset(self):
|
|
user = self.request.user
|
|
if user.is_anonymous:
|
|
return []
|
|
events = set(self.queryset.filter(creator=user))
|
|
for club in user.authorized_clubs.all():
|
|
for event in club.event_set.all():
|
|
events.add(event)
|
|
return events
|
|
|
|
class TournamentViewSet(viewsets.ModelViewSet):
|
|
queryset = Tournament.objects.all()
|
|
serializer_class = TournamentSerializer
|
|
|
|
def get_queryset(self):
|
|
user = self.request.user
|
|
if user.is_anonymous:
|
|
return []
|
|
tournaments = set(self.queryset.filter(event__creator=user))
|
|
for club in user.authorized_clubs.all():
|
|
for tournament in club.tournaments_set():
|
|
tournaments.add(tournament)
|
|
return tournaments
|
|
|
|
class PurchaseViewSet(viewsets.ModelViewSet):
|
|
queryset = Purchase.objects.all()
|
|
serializer_class = PurchaseSerializer
|
|
|
|
def get_queryset(self):
|
|
if self.request.user:
|
|
return self.queryset.filter(user=self.request.user)
|
|
return []
|
|
|
|
def put(self, request, pk):
|
|
raise MethodNotAllowed('PUT')
|
|
|
|
def patch(self, request, pk):
|
|
raise MethodNotAllowed('PATCH')
|
|
|
|
def delete(self, request, pk):
|
|
raise MethodNotAllowed('DELETE')
|
|
|
|
# class ExpandedTournamentViewSet(viewsets.ModelViewSet):
|
|
# queryset = Tournament.objects.all()
|
|
# serializer_class = ExpandedTournamentSerializer
|
|
|
|
class RoundViewSet(viewsets.ModelViewSet):
|
|
queryset = Round.objects.all()
|
|
serializer_class = RoundSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(tournament=tournament_id)
|
|
if self.request.user:
|
|
return self.queryset.filter(tournament__event__creator=self.request.user)
|
|
return []
|
|
|
|
class GroupStageViewSet(viewsets.ModelViewSet):
|
|
queryset = GroupStage.objects.all()
|
|
serializer_class = GroupStageSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(tournament=tournament_id)
|
|
if self.request.user:
|
|
return self.queryset.filter(tournament__event__creator=self.request.user)
|
|
return []
|
|
|
|
class MatchViewSet(viewsets.ModelViewSet):
|
|
queryset = Match.objects.all()
|
|
serializer_class = MatchSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(Q(group_stage__tournament=tournament_id) | Q(round__tournament=tournament_id))
|
|
if self.request.user:
|
|
return self.queryset.filter(Q(group_stage__tournament__event__creator=self.request.user) | Q(round__tournament__event__creator=self.request.user))
|
|
return []
|
|
|
|
class TeamScoreViewSet(viewsets.ModelViewSet):
|
|
queryset = TeamScore.objects.all()
|
|
serializer_class = TeamScoreSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(team_registration__tournament=tournament_id)
|
|
if self.request.user:
|
|
return self.queryset.filter(team_registration__tournament__event__creator=self.request.user)
|
|
return []
|
|
|
|
class TeamRegistrationViewSet(viewsets.ModelViewSet):
|
|
queryset = TeamRegistration.objects.all()
|
|
serializer_class = TeamRegistrationSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(tournament=tournament_id)
|
|
if self.request.user:
|
|
return self.queryset.filter(tournament__event__creator=self.request.user)
|
|
return []
|
|
|
|
class PlayerRegistrationViewSet(viewsets.ModelViewSet):
|
|
queryset = PlayerRegistration.objects.all()
|
|
serializer_class = PlayerRegistrationSerializer
|
|
|
|
def get_queryset(self):
|
|
tournament_id = self.request.query_params.get('tournament')
|
|
if tournament_id:
|
|
return self.queryset.filter(team_registration__tournament=tournament_id)
|
|
if self.request.user:
|
|
return self.queryset.filter(team_registration__tournament__event__creator=self.request.user)
|
|
return []
|
|
|
|
class CourtViewSet(viewsets.ModelViewSet):
|
|
queryset = Court.objects.all()
|
|
serializer_class = CourtSerializer
|
|
|
|
class DateIntervalViewSet(viewsets.ModelViewSet):
|
|
queryset = DateInterval.objects.all()
|
|
serializer_class = DateIntervalSerializer
|
|
|
|
def get_queryset(self):
|
|
if self.request.user:
|
|
return self.queryset.filter(event__creator=self.request.user)
|
|
return []
|
|
|
|
class FailedApiCallViewSet(viewsets.ModelViewSet):
|
|
queryset = FailedApiCall.objects.all()
|
|
serializer_class = FailedApiCallSerializer
|
|
permission_classes = [] # FailedApiCall are public whereas the other requests are only for logged users
|
|
|
|
def get_queryset(self):
|
|
return []
|
|
|
|
def perform_create(self, serializer):
|
|
if self.request.user.is_anonymous == False:
|
|
serializer.save(user=self.request.user)
|
|
else:
|
|
serializer.save()
|
|
|
|
class LogViewSet(viewsets.ModelViewSet):
|
|
queryset = Log.objects.all()
|
|
serializer_class = LogSerializer
|
|
permission_classes = [] # Log are public whereas the other requests are only for logged users
|
|
|
|
def get_queryset(self):
|
|
return []
|
|
|
|
def perform_create(self, serializer):
|
|
if self.request.user.is_anonymous == False:
|
|
serializer.save(user=self.request.user)
|
|
else:
|
|
serializer.save()
|
|
|
|
class DeviceTokenViewSet(viewsets.ModelViewSet):
|
|
queryset = DeviceToken.objects.all()
|
|
serializer_class = DeviceTokenSerializer
|
|
|
|
def get_queryset(self):
|
|
if self.request.user:
|
|
return self.queryset.filter(user=self.request.user)
|
|
return []
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
value = request.data.get('value')
|
|
if DeviceToken.objects.filter(value=value).exists():
|
|
return Response({"detail": "This device token is already registered."}, status=208)
|
|
|
|
serializer = self.get_serializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
self.perform_create(serializer)
|
|
headers = self.get_success_headers(serializer.data)
|
|
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
|
|
|
|
def perform_create(self, serializer):
|
|
serializer.save(user=self.request.user)
|
|
|