Model update

padelclub_backend/urls.py

@@ -23,6 +23,12 @@ router = routers.DefaultRouter()
 router.register(r'users', views.UserViewSet)
 router.register(r'clubs', views.ClubViewSet)
 router.register(r'tournaments', views.TournamentViewSet)
+router.register(r'events', views.EventViewSet)
+router.register(r'group_stages', views.GroupStageViewSet)
+router.register(r'matches', views.MatchViewSet)
+router.register(r'team_states', views.TeamStateViewSet)
+router.register(r'team_registrations', views.TeamRegistrationViewSet)
+router.register(r'player_registrations', views.PlayerRegistrationViewSet)
 
 urlpatterns = [
     path('api/', include(router.urls)),

tournaments/admin.py

@@ -1,10 +1,10 @@
 from django.contrib import admin
-from .models import Club, Tournament
+from .models import Club, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamState, TeamRegistration, PlayerRegistration
 from django.contrib.auth.admin import UserAdmin
 from django.contrib.auth.forms import UserCreationForm, UserChangeForm
 
 from .forms import CustomUserCreationForm, CustomUserChangeForm
-from .models import CustomUser
+
 
 class CustomUserAdmin(UserAdmin):
     form = CustomUserChangeForm
@@ -26,4 +26,10 @@ class CustomUserAdmin(UserAdmin):
 
 admin.site.register(CustomUser, CustomUserAdmin)
 admin.site.register(Club)
-admin.site.register(Tournament)
+admin.site.register(Event)
+admin.site.register(Round)
+admin.site.register(GroupStage)
+admin.site.register(Match)
+admin.site.register(TeamState)
+admin.site.register(TeamRegistration)
+admin.site.register(PlayerRegistration)

tournaments/models.py

@@ -2,32 +2,82 @@ from django.db import models
 from django.contrib.auth.models import AbstractUser
 import uuid
 
+import tournaments
+
 class Club(models.Model):
-    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=True)
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    name = models.CharField(max_length=200)
+    name = models.CharField(max_length=50)
+    acronym = models.CharField(max_length=10)
+    phone = models.CharField(max_length=15, null=True, blank=True)
+    code = models.CharField(max_length=10, null=True, blank=True)
+    federal_club_data = models.JSONField(null=True, blank=True)
+
     address = models.CharField(max_length=200, null=True, blank=True)
+    city = models.CharField(max_length=100, null=True, blank=True)
+    zip_code = models.CharField(max_length=10, null=True, blank=True)
+    latitude = models.FloatField(null=True, blank=True)
+    longitude = models.FloatField(null=True, blank=True)
 
     def __str__(self):
         return self.name
 
 class CustomUser(AbstractUser):
     pass
-    id = models.UUIDField(primary_key=True, default=uuid.uuid4)
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    umpire_code = models.CharField(max_length=200, blank=True, null=True)
+    umpire_code = models.CharField(max_length=50, blank=True, null=True)
-    club = models.ForeignKey(Club, null=True, on_delete=models.SET_NULL)
+    clubs = models.ManyToManyField(Club)
+    phone = models.CharField(max_length=15, null=True, blank=True)
+    first_name = models.CharField(max_length=50)
+    last_name = models.CharField(max_length=50)
+    licence_id = models.CharField(max_length=10, null=True, blank=True)
 
     def __str__(self):
         return self.username
 
 class Event(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     club = models.ForeignKey(Club, on_delete=models.CASCADE)
+    date = models.DateField()
+    name = models.CharField(max_length=200, null=True, blank=True)
+    federal_tournament_data = models.JSONField(null=True, blank=True)
+    court_count = models.IntegerField(null=True, blank=True)
+    tenup_id = models.IntegerField(null=True, blank=True)
+    group_stage_format = models.IntegerField(null=True, blank=True)
+    round_format = models.IntegerField(null=True, blank=True)
+    loser_round_format = models.IntegerField(null=True, blank=True)
 
 class Tournament(models.Model):
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     event = models.ForeignKey(Event, on_delete=models.CASCADE)
-    name = models.CharField(max_length=200)
+    user = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
-    date = models.DateField(null=True, blank=True)
+    name = models.CharField(max_length=200, null=True, blank=True)
-    private = models.BooleanField()
+    start_date = models.DateField()
+    end_date = models.DateField(null=True, blank=True)
+    creation_date = models.DateField()
+    is_private = models.BooleanField()
+    format = models.IntegerField(null=True, blank=True)
+    group_stage_format = models.IntegerField(null=True, blank=True)
+    round_format = models.IntegerField(null=True, blank=True)
+    loser_round_format = models.IntegerField(null=True, blank=True)
+    bracket_sort_mode = models.IntegerField()
+    group_stage_count = models.IntegerField()
+    rank_source_date = models.DateField(null=True, blank=True)
+    custom_name = models.CharField(max_length=100, null=True, blank=True)
+    day_duration = models.IntegerField()
+    team_count = models.IntegerField()
+    team_sorting = models.IntegerField()
+    federal_category = models.IntegerField()
+    federal_level_category = models.IntegerField()
+    federal_age_category = models.IntegerField()
+    group_stage_court_count = models.IntegerField(null=True, blank=True)
+    seed_count = models.IntegerField()
+    closed_registration_date = models.DateField(null=True, blank=True)
+    additional_qualified = models.IntegerField()
+    court_count = models.IntegerField(null=True, blank=True)
+    prioritize_club_members = models.BooleanField()
+    qualified_per_group_stage = models.IntegerField()
+    teams_per_group_stage = models.IntegerField()
+    #estimated_end_date = models.DateField(null=True, blank=True)
 
     def __str__(self):
         return self.name
@@ -36,34 +86,38 @@ class Round(models.Model):
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     index = models.IntegerField(null=True, blank=True)
     tournament = models.ForeignKey(Club, on_delete=models.CASCADE)
-    # winner = models.ForeignKey('self', on_delete=models.CASCADE)
     loser = models.ForeignKey('self', on_delete=models.CASCADE)
+    format = models.IntegerField(null=True, blank=True)
 
 class GroupStage(models.Model):
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     index = models.IntegerField(null=True, blank=True)
+    tournament = models.ForeignKey(Club, on_delete=models.CASCADE)
+    format = models.IntegerField(null=True, blank=True)
 
 class Match(models.Model):
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
     round = models.ForeignKey(Round, on_delete=models.CASCADE)
+    group_stage = models.ForeignKey(GroupStage, on_delete=models.CASCADE)
     index = models.IntegerField(null=True, blank=True)
     format = models.IntegerField(null=True, blank=True)
-    group_stage = models.ForeignKey(GroupStage, on_delete=models.CASCADE)
     court = models.IntegerField(null=True, blank=True)
     start_date = models.DateField(null=True, blank=True)
     end_date = models.DateField(null=True, blank=True)
+    serve_team_id = models.UUIDField(null=True, blank=True)
+    winning_team_id = models.UUIDField(null=True, blank=True)
+    loser_team_id = models.UUIDField(null=True, blank=True)
 
 class TeamState(models.Model):
-    score_team = models.CharField(max_length=200)
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    match = models.ForeignKey(Match, on_delete=models.CASCADE)
+    score = models.CharField(max_length=200)
     walk_out = models.IntegerField(null=True, blank=True) #id, int of the walked_out team
     lucky_loser = models.BooleanField()
-    serve = models.BooleanField()
-    match = models.ForeignKey(Match, on_delete=models.CASCADE)
-    has_won = models.BooleanField()
 
 class TeamRegistration(models.Model):
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    match = models.ForeignKey(Club, on_delete=models.CASCADE)
+    tournament = models.ForeignKey(Tournament, on_delete=models.CASCADE)
     registration_date = models.DateField(null=True, blank=True)
     call_date = models.DateField(null=True, blank=True)
     initial_position = models.IntegerField(null=True, blank=True)
@@ -71,17 +125,26 @@ class TeamRegistration(models.Model):
     group_stage = models.ForeignKey(GroupStage, on_delete=models.CASCADE)
     logo = models.CharField(max_length=200, null=True, blank=True)
 
-# class Group(models.Model):
-#     id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-#     # player = models.ForeignKey(Club, on_delete=models.CASCADE)
-
 class PlayerRegistration(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    team_registration = models.ForeignKey(TeamRegistration, on_delete=models.CASCADE)
+    team_state = models.ManyToManyField(TeamState)
     first_name = models.CharField(max_length=200)
     last_name = models.CharField(max_length=200)
     licence_id = models.CharField(max_length=200)
     rank = models.IntegerField(null=True, blank=True)
     has_paid = models.BooleanField()
 
-    team = models.ForeignKey(TeamRegistration, on_delete=models.CASCADE)
-    teamState = models.ManyToManyField(TeamState)
     # player = models.ForeignKey(Club, on_delete=models.CASCADE)
+
+# class Set(models.Model):
+
+# class Game(models.Model):
+#     set = models.ForeignKey(Set, on_delete=models.CASCADE)
+#     format = models.IntegerField()
+
+# class Point(models.Model):
+#     game = models.ForeignKey(Game, on_delete=models.CASCADE)
+#     action = models.IntegerField()
+#     date = models.DateField()
+#     team_id  = models.IntegerField()

tournaments/serializers.py

@@ -1,5 +1,5 @@
 from rest_framework import serializers
-from .models import Club, Tournament, CustomUser
+from .models import Club, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamState, TeamRegistration, PlayerRegistration
 from django.contrib.auth import password_validation
 from django.utils.translation import gettext_lazy as _
 
@@ -17,18 +17,74 @@ class UserSerializer(serializers.HyperlinkedModelSerializer):
     class Meta:
         club_id = serializers.PrimaryKeyRelatedField(queryset=Club.objects.all())
         model = CustomUser
-        fields = ['id', 'username', 'password', 'club_id', 'umpire_code']
+        fields = ['id', 'username', 'password', 'club_id', 'umpire_code', 'clubs', 'phone', 'first_name', 'last_name', 'licence_id']
 
 class ClubSerializer(serializers.HyperlinkedModelSerializer):
     class Meta:
         model = Club
-        fields = ['id', 'name', 'address']
+        fields = ['id', 'name', 'acronym', 'phone', 'code', 'federal_club_data', 'address', 'city', 'zip_code', 'latitude', 'longitude']
 
 class TournamentSerializer(serializers.HyperlinkedModelSerializer):
     class Meta:
         club_id = serializers.PrimaryKeyRelatedField(queryset=Club.objects.all())
+        event_id = serializers.PrimaryKeyRelatedField(queryset=Event.objects.all())
+        user_id = serializers.PrimaryKeyRelatedField(queryset=CustomUser.objects.all())
         model = Tournament
-        fields = ['id', 'name', 'club_id']
+        fields = ['id', 'name', 'club_id', 'event_id', 'user_id', 'start_date', 'end_date', 'creation_date',
+            'is_private', 'format', 'group_stage_format', 'round_format', 'loser_round_format', 'bracket_sort_mode',
+            'group_stage_count', 'rank_source_date', 'custom_name', 'day_duration', 'team_count', 'team_sorting',
+            'federal_category', 'federal_level_category', 'federal_age_category', 'group_stage_court_count',
+            'seed_count', 'closed_registration_date', 'additional_qualified', 'court_count', 'prioritize_club_members',
+            'qualified_per_group_stage', 'teams_per_group_stage']
+
+class EventSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        club_id = serializers.PrimaryKeyRelatedField(queryset=Club.objects.all())
+        model = Event
+        fields = ['id', 'club_id', 'date', 'name', 'federal_tournament_data', 'court_count', 'tenup_id',
+            'group_stage_format', 'round_format', 'loser_round_format']
+
+class RoundSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        tournament_id = serializers.PrimaryKeyRelatedField(queryset=Tournament.objects.all())
+        loser_id = serializers.PrimaryKeyRelatedField(queryset=Round.objects.all())
+        model = Round
+        fields = ['id', 'index', 'tournament_id', 'loser_id', 'format']
+
+class GroupStageSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        tournament_id = serializers.PrimaryKeyRelatedField(queryset=Tournament.objects.all())
+        model = GroupStage
+        fields = ['id', 'index', 'tournament_id', 'format']
+
+class MatchSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        round_id = serializers.PrimaryKeyRelatedField(queryset=Round.objects.all())
+        group_stage_id = serializers.PrimaryKeyRelatedField(queryset=GroupStage.objects.all())
+        model = Match
+        fields = ['id', 'round_id', 'group_stage_id', 'index', 'format', 'court', 'start_date', 'end_date',
+            'serve_team_id', 'winning_team_id', 'loser_team_id']
+
+class TeamStateSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        match_id = serializers.PrimaryKeyRelatedField(queryset=Match.objects.all())
+        model = TeamState
+        fields = ['id', 'match_id', 'score', 'walk_out', 'lucky_loser']
+
+class TeamRegistrationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        match_id = serializers.PrimaryKeyRelatedField(queryset=Match.objects.all())
+        group_stage_id = serializers.PrimaryKeyRelatedField(queryset=GroupStage.objects.all())
+        model = TeamRegistration
+        fields = ['id', 'match_id', 'group_stage_id', 'registration_date', 'call_date', 'initial_position',
+            'group_stage_position', 'logo']
+
+class PlayerRegistrationSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        team_registration_id = serializers.PrimaryKeyRelatedField(queryset=TeamRegistration.objects.all())
+        team_state_id = serializers.PrimaryKeyRelatedField(queryset=TeamState.objects.all())
+        model = PlayerRegistration
+        fields = ['id', 'team_registration_id', 'team_state_id', 'first_name', 'last_name', 'licence_id', 'rank', 'has_paid']
 
 class ChangePasswordSerializer(serializers.Serializer):
     old_password = serializers.CharField(max_length=128, write_only=True, required=True)

tournaments/views.py

@@ -1,7 +1,7 @@
 from django.shortcuts import render
 from django.http import HttpResponse
-from .serializers import ClubSerializer, TournamentSerializer, UserSerializer, ChangePasswordSerializer
+from .serializers import ClubSerializer, TournamentSerializer, UserSerializer, ChangePasswordSerializer, EventSerializer, RoundSerializer, GroupStageSerializer, MatchSerializer, TeamStateSerializer, TeamRegistrationSerializer, PlayerRegistrationSerializer
-from .models import Club, Tournament, CustomUser
+from .models import Club, Tournament, CustomUser, Event, Round, GroupStage, Match, TeamState, TeamRegistration, PlayerRegistration
 from rest_framework import viewsets, permissions
 from rest_framework.authtoken.models import Token
 from rest_framework.response import Response
@@ -46,3 +46,31 @@ class ChangePasswordView(UpdateAPIView):
         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 TeamStateViewSet(viewsets.ModelViewSet):
+    queryset = TeamState.objects.all()
+    serializer_class = TeamStateSerializer
+
+class TeamRegistrationViewSet(viewsets.ModelViewSet):
+    queryset = TeamRegistration.objects.all()
+    serializer_class = TeamRegistrationSerializer
+
+class PlayerRegistrationViewSet(viewsets.ModelViewSet):
+    queryset = PlayerRegistration.objects.all()
+    serializer_class = PlayerRegistrationSerializer