padelclub_backend/tournaments/views.py

from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse

from tournaments.models import group_stage
from .serializers import ClubSerializer, TournamentSerializer, UserSerializer, ChangePasswordSerializer, EventSerializer, RoundSerializer, GroupStageSerializer, MatchSerializer, TeamScoreSerializer, TeamRegistrationSerializer, PlayerRegistrationSerializer, LiveMatchSerializer
from .models import Club, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamScore, TeamRegistration, PlayerRegistration
from .models import TeamSummon
from datetime import datetime
import datetime

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 django.template import loader
from datetime import date
from django.http import JsonResponse
from django.db.models import Q
import json

def index(request):

    today = date.today()

    club_id = request.GET.get('club')
    q_is_private = Q(is_private=False)

    q_future = [q_is_private, Q(end_date__isnull=True, start_date__gt=today)]
    q_live = [q_is_private, Q(end_date__isnull=True, start_date__lte=today)]
    q_ended = [q_is_private, Q(end_date__isnull=False)]

    club = None
    if club_id:
        club = get_object_or_404(Club, pk=club_id)

        q_club = Q(event__club=club)
        q_future.append(q_club)
        q_live.append(q_club)
        q_ended.append(q_club)

    future_tournaments = Tournament.objects.filter(*q_future).order_by('start_date')
    live_tournaments = Tournament.objects.filter(*q_live).order_by('start_date')
    ended_tournaments = Tournament.objects.filter(*q_ended).order_by('start_date')
    return render(
        request,
        "tournaments/tournaments.html",
        {
            'future': future_tournaments,
            'live': live_tournaments,
            'ended': ended_tournaments,
            'club': club,
        }
    )

def clubs(request):
    clubs = Club.objects.all().order_by('name')
    return render(request, 'tournaments/clubs.html', {
        'clubs': clubs,
    })

def club(request, club_id):
    club = get_object_or_404(Club, pk=club_id)
    return render(request, 'tournaments/summons.html', {
        'tournament': tournament,
        'team_summons': team_summons,
    })

def tournament(request, tournament_id):

    tournament = get_object_or_404(Tournament, pk=tournament_id)

    round_id = request.GET.get('round')
    group_stage_id = request.GET.get('group_stage')
    match_groups = tournament.match_groups(False, group_stage_id, round_id)

    rounds = tournament.round_set.filter(loser=None).order_by('-index')
    group_stages = tournament.groupstage_set.order_by('index')

    return render(request, 'tournaments/matches.html', {
        'tournament': tournament,
        'rounds': rounds,
        'group_stages': group_stages,
        'match_groups': match_groups,
    })

def tournament_summons(request, tournament_id):

    tournament = get_object_or_404(Tournament, pk=tournament_id)
    team_summons = tournament.team_summons()

    return render(request, 'tournaments/summons.html', {
        'tournament': tournament,
        'team_summons': team_summons,
    })

def tournament_broadcasted_summons(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    return render(request, 'tournaments/broadcasted_summons.html', {
        'tournament': tournament,
    })

def tournament_summons_json(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    team_summons = [summon.to_dict() for summon in tournament.team_summons()]
    data = json.dumps(team_summons)
    return HttpResponse(data, content_type='application/json')

def tournament_broadcast(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    return render(request, 'tournaments/broadcasted.html', {
        'tournament': tournament,
    })

def tournament_matches(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    return render(request, 'tournaments/broadcasted_matches.html', {
        'tournament': tournament,
    })

def broadcast_json(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)

    matches = [m.__dict__ for m in tournament.live_matches()]
    group_stages = [gs.to_dict() for gs in tournament.live_group_stages()]
    team_summons = [summon.to_dict() for summon in tournament.team_summons()]

    broadcast = {
        'matches': matches,
        'group_stages': group_stages,
        'summons': team_summons,
    }

    data = json.dumps(broadcast)
    return HttpResponse(data, content_type='application/json')

def tournament_matches_json(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    live_matches = tournament.live_matches()
    data = json.dumps(live_matches, default=vars)
    return HttpResponse(data, content_type='application/json')

def tournament_group_stages(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    live_group_stages = list(tournament.live_group_stages())
    return render(request, 'tournaments/group_stages.html', {
        'tournament': tournament,
        'group_stages': live_group_stages,
    })

def tournament_broadcasted_group_stages(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)
    return render(request, 'tournaments/broadcasted_group_stages.html', {
        'tournament': tournament,
    })

def tournament_live_group_stage_json(request, tournament_id):
    tournament = get_object_or_404(Tournament, pk=tournament_id)

    gs_dicts = [gs.to_dict() for gs in tournament.live_group_stages()]
    # group_stages = tournament.live_group_stages()
    data = json.dumps(gs_dicts)
    return HttpResponse(data, content_type='application/json')

def players(request):
    return render(request, 'tournaments/test.html')

##### API #####

@api_view(['GET'])
def user_by_token(request):
    # return Response({"message": "Hello for today! See you tomorrow!"})
    # key = request.data['token']
    # token = Token.objects.get(key=key)
    # user = CustomUser.objects.get(username=token.user)
    serializer = UserSerializer(request.user)
    return Response(serializer.data, status=status.HTTP_200_OK)

class UserViewSet(viewsets.ModelViewSet):
    queryset = CustomUser.objects.all()
    serializer_class = UserSerializer

class ClubViewSet(viewsets.ModelViewSet):
    queryset = Club.objects.all()
    serializer_class = ClubSerializer

class TournamentViewSet(viewsets.ModelViewSet):
    queryset = Tournament.objects.all()
    serializer_class = TournamentSerializer

# class ExpandedTournamentViewSet(viewsets.ModelViewSet):
#     queryset = Tournament.objects.all()
#     serializer_class = ExpandedTournamentSerializer

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 EventViewSet(viewsets.ModelViewSet):
    queryset = Event.objects.all()
    serializer_class = EventSerializer

class RoundViewSet(viewsets.ModelViewSet):
    queryset = Round.objects.all()
    serializer_class = RoundSerializer

class GroupStageViewSet(viewsets.ModelViewSet):
    queryset = GroupStage.objects.all()
    serializer_class = GroupStageSerializer

class MatchViewSet(viewsets.ModelViewSet):
    queryset = Match.objects.all()
    serializer_class = MatchSerializer

class TeamScoreViewSet(viewsets.ModelViewSet):
    queryset = TeamScore.objects.all()
    serializer_class = TeamScoreSerializer

class TeamRegistrationViewSet(viewsets.ModelViewSet):
    queryset = TeamRegistration.objects.all()
    serializer_class = TeamRegistrationSerializer

class PlayerRegistrationViewSet(viewsets.ModelViewSet):
    queryset = PlayerRegistration.objects.all()
    serializer_class = PlayerRegistrationSerializer