wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/example_app/viewsets/teamresult.py

@@ -0,0 +1,106 @@
+from django.db.models import Count, IntegerField, OuterRef, Q, QuerySet, Subquery
+from django.db.models.functions import Coalesce
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import (
+    TeamResultsFilter,
+    TeamResultsLeagueFilter,
+)
+from wbcore.contrib.example_app.models import Match, TeamResults
+from wbcore.contrib.example_app.serializers import (
+    TeamResultsModelSerializer,
+    TeamResultsRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import (
+    TeamResultsDisplayConfig,
+    TeamResultsLeagueDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import TeamResultsEndpointConfig
+from wbcore.contrib.example_app.viewsets.titles import (
+    TeamResultsLeagueTitleConfig,
+    TeamResultsTitleConfig,
+)
+
+
+class TeamResultsModelViewSet(viewsets.ModelViewSet):
+    display_config_class = TeamResultsDisplayConfig
+    queryset = TeamResults.objects.all()
+    search_fields = ("team__name", "league__computed_str")
+    ordering_fields = (
+        "league__computed_str",
+        "points",
+        "match_point_difference",
+        "match_points_for",
+        "team__name",
+        "match_points_against",
+        "wins",
+        "draws",
+        "losses",
+    )
+    ordering = (
+        "league__computed_str",
+        "-points",
+        "-match_point_difference",
+        "-match_points_for",
+        "team__name",
+    )
+    serializer_class = TeamResultsModelSerializer
+    title_config_class = TeamResultsTitleConfig
+    filterset_class = TeamResultsFilter
+    endpoint_config_class = TeamResultsEndpointConfig
+
+    def get_queryset(self) -> QuerySet[TeamResults]:
+        games_subquery = (
+            Match.objects.filter(
+                Q(league=OuterRef("league"))
+                & Q(Q(home=OuterRef("team")) | Q(away=OuterRef("team")))
+                & Q(status=Match.MatchStatus.FINISHED)
+            )
+            .values("league__pk")
+            .annotate(games=Count("id"))
+            .values("games")
+        )
+
+        qs = (
+            super()
+            .get_queryset()
+            .select_related("league", "team")
+            .annotate(
+                games_played=Coalesce(Subquery(games_subquery, output_field=IntegerField()), 0),
+            )
+        )
+        return qs
+
+
+class TeamResultsRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = TeamResults.objects.all()
+    serializer_class = TeamResultsRepresentationSerializer
+    search_fields = ("team__name", "league__computed_str")
+
+
+class TeamResultsLeagueModelViewSet(TeamResultsModelViewSet):
+    title_config_class = TeamResultsLeagueTitleConfig
+    display_config_class = TeamResultsLeagueDisplayConfig
+    filterset_class = TeamResultsLeagueFilter
+    search_fields = ("team__name",)
+    ordering_fields = (
+        "points",
+        "match_point_difference",
+        "match_points_for",
+        "team__name",
+        "match_points_against",
+        "wins",
+        "draws",
+        "losses",
+    )
+    ordering = (
+        "-points",
+        "-match_point_difference",
+        "-match_points_for",
+        "team__name",
+    )
+
+    def get_queryset(self) -> QuerySet[TeamResults]:
+        queryset = super().get_queryset()
+        if league_id := self.kwargs.get("league_id"):
+            queryset = queryset.filter(league=league_id)
+        return queryset

wbcore/contrib/example_app/viewsets/titles/__init__.py

@@ -0,0 +1,9 @@
+from .person import SportPersonTitleConfig, PlayerTitleConfig, PlayerTeamTitleConfig
+from .sport import SportTitleConfig
+from .league import LeagueTitleConfig, LeagueSportTitleConfig
+from .stadium import StadiumTitleConfig
+from .team import TeamTitleConfig, TeamStadiumTitleConfig
+from .role import RoleTitleConfig
+from .match import MatchTitleConfig, MatchStadiumTitleConfig, MatchLeagueTitleConfig
+from .event import EventTitleConfig, EventTypeSportTitleConfig, EventTypeTitleConfig, PlayerStatisticsChartTitleConfig
+from .teamresult import TeamResultsTitleConfig, TeamResultsLeagueTitleConfig

wbcore/contrib/example_app/viewsets/titles/event.py

@@ -0,0 +1,41 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.example_app.models import Player, Sport
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class EventTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Events")
+
+    def get_create_title(self) -> str:
+        return _("Create Event")
+
+    def get_instance_title(self) -> str:
+        return _("Event")
+
+
+class PlayerStatisticsChartTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        player_name = Player.objects.get(id=self.view.kwargs["player_id"])
+        return _("Player Statistics {}").format(player_name.computed_str)
+
+
+class EventTypeTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Event Types")
+
+    def get_create_title(self) -> str:
+        return _("Create Event Type")
+
+    def get_instance_title(self) -> str:
+        return _("Event Type")
+
+
+class EventTypeSportTitleConfig(EventTypeTitleConfig):
+    def get_create_title(self) -> str:
+        if sport_id := self.view.kwargs.get("sport_id"):
+            try:
+                return _("Create {} Event Type").format(Sport.objects.get(id=sport_id).name)
+            except Sport.DoesNotExist:
+                pass
+        return super().get_create_title()

wbcore/contrib/example_app/viewsets/titles/league.py

@@ -0,0 +1,24 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.example_app.models import Sport
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class LeagueTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Leagues")
+
+    def get_create_title(self) -> str:
+        return _("Create League")
+
+    def get_instance_title(self) -> str:
+        return _("League")
+
+
+class LeagueSportTitleConfig(LeagueTitleConfig):
+    def get_create_title(self) -> str:
+        if sport_id := self.view.kwargs.get("sport_id"):
+            try:
+                return _("Create {} League").format(Sport.objects.get(id=sport_id).name)
+            except Sport.DoesNotExist:
+                pass
+        return super().get_create_title()

wbcore/contrib/example_app/viewsets/titles/match.py

@@ -0,0 +1,34 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.example_app.models import League, Stadium
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class MatchTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Matches")
+
+    def get_create_title(self) -> str:
+        return _("Create Match")
+
+    def get_instance_title(self) -> str:
+        return _("Match")
+
+
+class MatchStadiumTitleConfig(MatchTitleConfig):
+    def get_create_title(self) -> str:
+        if stadium_id := self.view.kwargs.get("stadium_id"):
+            try:
+                return _("Create Match In {}").format(Stadium.objects.get(id=stadium_id).name)
+            except Stadium.DoesNotExist:
+                pass
+        return super().get_create_title()
+
+
+class MatchLeagueTitleConfig(MatchTitleConfig):
+    def get_create_title(self) -> str:
+        if league_id := self.view.kwargs.get("league_id"):
+            try:
+                return _("Create Match In {}").format(League.objects.get(id=league_id).name)
+            except League.DoesNotExist:
+                pass
+        return super().get_create_title()

wbcore/contrib/example_app/viewsets/titles/person.py

@@ -0,0 +1,35 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.example_app.models import Team
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class SportPersonTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Persons")
+
+    def get_create_title(self) -> str:
+        return _("Create Person")
+
+    def get_instance_title(self) -> str:
+        return _("Person")
+
+
+class PlayerTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Players")
+
+    def get_create_title(self) -> str:
+        return _("Create Player")
+
+    def get_instance_title(self) -> str:
+        return _("Player")
+
+
+class PlayerTeamTitleConfig(PlayerTitleConfig):
+    def get_create_title(self) -> str:
+        if team_id := self.view.kwargs.get("team_id"):
+            try:
+                return _("Create Player For {}").format(Team.objects.get(id=team_id).name)
+            except Team.DoesNotExist:
+                pass
+        return super().get_create_title()

wbcore/contrib/example_app/viewsets/titles/role.py

@@ -0,0 +1,13 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class RoleTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Roles")
+
+    def get_create_title(self) -> str:
+        return _("Create Role")
+
+    def get_instance_title(self) -> str:
+        return _("Role")

wbcore/contrib/example_app/viewsets/titles/sport.py

@@ -0,0 +1,13 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class SportTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Sports")
+
+    def get_create_title(self) -> str:
+        return _("Create Sport")
+
+    def get_instance_title(self) -> str:
+        return _("Sport")

wbcore/contrib/example_app/viewsets/titles/stadium.py

@@ -0,0 +1,13 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class StadiumTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Stadiums")
+
+    def get_create_title(self) -> str:
+        return _("Create Stadium")
+
+    def get_instance_title(self) -> str:
+        return _("Stadium")

wbcore/contrib/example_app/viewsets/titles/team.py

@@ -0,0 +1,24 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.example_app.models import Stadium
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class TeamTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Teams")
+
+    def get_create_title(self) -> str:
+        return _("Create Team")
+
+    def get_instance_title(self) -> str:
+        return _("Team")
+
+
+class TeamStadiumTitleConfig(TeamTitleConfig):
+    def get_create_title(self) -> str:
+        if stadium_id := self.view.kwargs.get("stadium_id"):
+            try:
+                return _("Create Team In {}").format(Stadium.objects.get(id=stadium_id).name)
+            except Stadium.DoesNotExist:
+                pass
+        return super().get_create_title()

wbcore/contrib/example_app/viewsets/titles/teamresult.py

@@ -0,0 +1,12 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class TeamResultsTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Team Results")
+
+
+class TeamResultsLeagueTitleConfig(TitleViewConfig):
+    def get_list_title(self) -> str:
+        return _("Table")

wbcore/contrib/geography/admin.py

@@ -0,0 +1,30 @@
+from django.contrib import admin
+from mptt.admin import MPTTModelAdmin
+
+from .models import Geography
+
+
+@admin.register(Geography)
+class GeographyAdmin(MPTTModelAdmin):
+    search_fields = ("name", "code_2", "code_3")
+    list_display = ("name", "code_2", "code_3", "parent")
+    raw_id_fields = ["parent"]
+    readonly_fields = ["level"]
+    fieldsets = (
+        (
+            "Main information",
+            {
+                "fields": (
+                    ("name", "short_name", "alternative_names", "representation"),
+                    ("code_2", "code_3", "code"),
+                    ("population", "ranking", "time_zone"),
+                    (
+                        "parent",
+                        "level",
+                    ),
+                    ("search_vector",),
+                )
+            },
+        ),
+    )
+    list_filter = ("level",)

wbcore/contrib/geography/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class GeographyConfig(AppConfig):
+    name = "wbcore.contrib.geography"

wbcore/contrib/geography/factories.py

@@ -0,0 +1,46 @@
+from itertools import product
+from string import ascii_uppercase
+
+import factory
+
+from .models import Geography
+
+POSSIBLE_COUNTRY_CODE_2 = ["".join(i) for i in product(ascii_uppercase, repeat=2)]
+POSSIBLE_COUNTRY_CODE_3 = ["".join(i) for i in product(ascii_uppercase, repeat=3)]
+
+
+class ContinentFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Geography
+
+    name = factory.Faker("text", max_nb_chars=10)
+
+
+class CountryFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Geography
+
+    code_3 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_3[n % len(POSSIBLE_COUNTRY_CODE_3)])
+    code_2 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_2[n % len(POSSIBLE_COUNTRY_CODE_2)])
+    parent = factory.LazyAttribute(lambda x: ContinentFactory.create())
+    name = factory.Faker("country")
+
+
+class StateFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Geography
+
+    code_3 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_3[n % len(POSSIBLE_COUNTRY_CODE_3)])
+    code_2 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_2[n % len(POSSIBLE_COUNTRY_CODE_2)])
+    parent = factory.SubFactory(CountryFactory)
+    name = factory.Faker("state")
+
+
+class CityFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Geography
+
+    code_3 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_3[n % len(POSSIBLE_COUNTRY_CODE_3)])
+    code_2 = factory.Sequence(lambda n: POSSIBLE_COUNTRY_CODE_2[n % len(POSSIBLE_COUNTRY_CODE_2)])
+    parent = factory.SubFactory(StateFactory)
+    name = factory.Faker("city")

wbcore/contrib/geography/import_export/resources/geography.py

@@ -0,0 +1,10 @@
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.geography.models import Geography
+
+
+class CountryForeignKeyWidget(ForeignKeyWidget):
+    def __init__(self, field="code_3", use_natural_foreign_keys=False, **kwargs):
+        super().__init__(Geography, field=field)
+
+    def get_queryset(self, value, row, *args, **kwargs):
+        return Geography.countries.all()

wbcore/contrib/geography/migrations/0001_initial.py

@@ -0,0 +1,110 @@
+# Generated by Django 4.1.8 on 2023-04-06 06:43
+
+import django.contrib.postgres.fields
+import django.contrib.postgres.indexes
+import django.contrib.postgres.search
+import django.db.models.deletion
+import mptt.fields
+import timezone_field.fields
+from django.contrib.postgres.operations import BtreeGinExtension, TrigramExtension
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        TrigramExtension(),
+        BtreeGinExtension(),
+        migrations.CreateModel(
+            name="Geography",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("name", models.CharField(max_length=255)),
+                ("short_name", models.CharField(max_length=255)),
+                (
+                    "alternative_names",
+                    django.contrib.postgres.fields.ArrayField(
+                        base_field=models.CharField(max_length=255),
+                        blank=True,
+                        default=list,
+                        help_text="Alternative Names",
+                        size=None,
+                        verbose_name="Alternative Names",
+                    ),
+                ),
+                ("representation", models.CharField(blank=True, default="", max_length=255)),
+                ("search_vector", django.contrib.postgres.search.SearchVectorField(null=True)),
+                ("trigram_search_vector", models.CharField(blank=True, max_length=1024, null=True)),
+                (
+                    "code_2",
+                    models.CharField(
+                        blank=True, max_length=2, null=True, verbose_name="2 Character Alphanumeric Code"
+                    ),
+                ),
+                (
+                    "code_3",
+                    models.CharField(
+                        blank=True, max_length=3, null=True, verbose_name="3 Character Alphanumeric Code"
+                    ),
+                ),
+                ("code", models.CharField(blank=True, max_length=16, null=True, verbose_name="Code")),
+                ("population", models.PositiveIntegerField(blank=True, null=True)),
+                ("ranking", models.PositiveIntegerField(default=1)),
+                (
+                    "time_zone",
+                    timezone_field.fields.TimeZoneField(blank=True, choices_display="WITH_GMT_OFFSET", null=True),
+                ),
+                ("lft", models.PositiveIntegerField(editable=False)),
+                ("rght", models.PositiveIntegerField(editable=False)),
+                ("tree_id", models.PositiveIntegerField(db_index=True, editable=False)),
+                ("level", models.PositiveIntegerField(editable=False)),
+                (
+                    "parent",
+                    mptt.fields.TreeForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="children",
+                        to="geography.geography",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name_plural": "Geographies",
+            },
+        ),
+        migrations.AddIndex(
+            model_name="geography",
+            index=django.contrib.postgres.indexes.GinIndex(fields=["search_vector"], name="geography_sv_gin_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="geography",
+            index=django.contrib.postgres.indexes.GinIndex(
+                fields=["trigram_search_vector"],
+                name="geography_trigram_sv_gin_idx",
+                opclasses=["gin_trgm_ops"],
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="geography",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("level", 1)),
+                fields=("level", "code_2"),
+                name="geography_geography_level_code2__uniq",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="geography",
+            constraint=models.UniqueConstraint(
+                condition=models.Q(("level", 1)),
+                fields=("level", "code_3"),
+                name="geography_geography_level_code3__uniq",
+            ),
+        ),
+    ]