wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/example_app/viewsets/league.py

@@ -0,0 +1,73 @@
+from django.db.models import QuerySet
+
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import LeagueFilter, LeagueSportFilter
+from wbcore.contrib.example_app.models import League
+from wbcore.contrib.example_app.serializers import (
+    LeagueModelSerializer,
+    LeagueRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import (
+    LeagueDisplayConfig,
+    LeagueSportDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import LeagueSportEndpointConfig
+from wbcore.contrib.example_app.viewsets.titles import (
+    LeagueSportTitleConfig,
+    LeagueTitleConfig,
+)
+
+
+class LeagueModelViewSet(viewsets.ModelViewSet):
+    display_config_class = LeagueDisplayConfig
+    queryset = League.objects.all()
+    search_fields = ("name", "sport__name")
+    serializer_class = LeagueModelSerializer
+    title_config_class = LeagueTitleConfig
+    ordering_fields = (
+        "name",
+        "country__name",
+        "established_date",
+        "commissioner__computed_str",
+        "website",
+        "sport__name",
+        "points_per_win",
+        "points_per_draw",
+        "points_per_loss",
+    )
+    ordering = ("name", "sport__name")
+    filterset_class = LeagueFilter
+
+    def get_queryset(self) -> QuerySet[League]:
+        return super().get_queryset().select_related("sport", "country", "commissioner")
+
+
+class LeagueSportModelViewSet(LeagueModelViewSet):
+    display_config_class = LeagueSportDisplayConfig
+    ordering_fields = (
+        "name",
+        "country__name",
+        "established_date",
+        "commissioner__computed_str",
+        "website",
+        "points_per_win",
+        "points_per_draw",
+        "points_per_loss",
+    )
+    ordering = ("name",)
+    filterset_class = LeagueSportFilter
+    endpoint_config_class = LeagueSportEndpointConfig
+    title_config_class = LeagueSportTitleConfig
+
+    def get_queryset(self) -> QuerySet[League]:
+        queryset = super().get_queryset()
+        if sport_id := self.kwargs.get("sport_id"):
+            queryset = queryset.filter(sport=sport_id)
+        return queryset
+
+
+class LeagueRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = League.objects.all()
+    serializer_class = LeagueRepresentationSerializer
+    search_fields = ("name",)
+    filterset_fields = ("sport",)

wbcore/contrib/example_app/viewsets/match.py

@@ -0,0 +1,120 @@
+from django.contrib.messages import warning
+from django.db.models import Q, QuerySet
+from django.utils.translation import gettext as _
+
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import (
+    MatchFilter,
+    MatchLeagueFilter,
+    MatchStadiumFilter,
+)
+from wbcore.contrib.example_app.models import Match
+from wbcore.contrib.example_app.serializers import (
+    MatchModelSerializer,
+    MatchRepresentationSerializer,
+    ReadOnlyMatchModelSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import (
+    MatchDisplayConfig,
+    MatchLeagueDisplayConfig,
+    MatchStadiumDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import (
+    MatchLeagueEndpointConfig,
+    MatchStadiumEndpointConfig,
+)
+from wbcore.contrib.example_app.viewsets.titles import (
+    MatchLeagueTitleConfig,
+    MatchStadiumTitleConfig,
+    MatchTitleConfig,
+)
+
+
+class MatchModelViewSet(viewsets.ModelViewSet):
+    display_config_class = MatchDisplayConfig
+    queryset = Match.objects.all()
+    serializer_class = MatchModelSerializer
+    title_config_class = MatchTitleConfig
+    search_fields = ("home__name", "away__name", "league__computed_str", "sport__name")
+    ordering = ("-date_time", "home__name", "away__name")
+    ordering_fields = (
+        "home__name",
+        "away__name",
+        "league__computed_str",
+        "date_time",
+        "stadium__name",
+        "score_home",
+        "score_away",
+        "referee__computed_str",
+        "sport__name",
+    )
+    filterset_class = MatchFilter
+
+    def get_serializer_class(self):
+        if "pk" in self.kwargs:
+            if match_obj := self.get_object():
+                if match_obj.status != Match.MatchStatus.SCHEDULED:
+                    return ReadOnlyMatchModelSerializer
+        return super().get_serializer_class()
+
+    def add_messages(self, request, instance: Match | None = None, **kwargs):
+        if instance and (home_stadium := instance.home.home_stadium) and instance.stadium.pk != home_stadium.pk:
+            warning(request, _("Home team's home stadium not selected!"))
+
+    def get_queryset(self) -> QuerySet[Match]:
+        queryset = super().get_queryset().select_related("home", "away", "stadium", "referee", "league", "sport")
+        if team_id := self.kwargs.get("team_id"):
+            queryset = queryset.filter(Q(home=team_id) | Q(away=team_id))
+        return queryset
+
+
+class MatchStadiumModelViewSet(MatchModelViewSet):
+    display_config_class = MatchStadiumDisplayConfig
+    ordering_fields = (
+        "home__name",
+        "away__name",
+        "date_time",
+        "score_home",
+        "score_away",
+        "referee__computed_str",
+        "league__computed_str",
+        "sport__name",
+    )
+    filterset_class = MatchStadiumFilter
+    endpoint_config_class = MatchStadiumEndpointConfig
+    title_config_class = MatchStadiumTitleConfig
+
+    def get_queryset(self) -> QuerySet[Match]:
+        queryset = super().get_queryset()
+        if stadium_id := self.kwargs.get("stadium_id"):
+            queryset = queryset.filter(stadium=stadium_id)
+        return queryset
+
+
+class MatchLeagueModelViewSet(MatchModelViewSet):
+    display_config_class = MatchLeagueDisplayConfig
+    ordering_fields = (
+        "home__name",
+        "away__name",
+        "date_time",
+        "score_home",
+        "score_away",
+        "referee__computed_str",
+        "stadium__name",
+        "sport__name",
+    )
+    filterset_class = MatchLeagueFilter
+    endpoint_config_class = MatchLeagueEndpointConfig
+    title_config_class = MatchLeagueTitleConfig
+
+    def get_queryset(self) -> QuerySet[Match]:
+        queryset = super().get_queryset()
+        if league_id := self.kwargs.get("league_id"):
+            queryset = queryset.filter(league=league_id)
+        return queryset
+
+
+class MatchRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Match.objects.all()
+    serializer_class = MatchRepresentationSerializer
+    search_fields = ("computed_str",)

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

@@ -0,0 +1 @@
+from .menus import EXAMPLE_APP_MENU

wbcore/contrib/example_app/viewsets/menu/menus.py

@@ -0,0 +1,103 @@
+from django.utils.translation import gettext_lazy as _
+
+from wbcore.menus import Menu, MenuItem
+
+TEAM_MENUITEM = MenuItem(
+    label=_("Teams"),
+    endpoint="example_app:team-list",
+    add=MenuItem(
+        label=_("Create Team"),
+        endpoint="example_app:team-list",
+    ),
+)
+LEAGUE_MENUITEM = MenuItem(
+    label=_("Leagues"),
+    endpoint="example_app:league-list",
+    add=MenuItem(
+        label=_("Create League"),
+        endpoint="example_app:league-list",
+    ),
+)
+STADIUM_MENUITEM = MenuItem(
+    label=_("Stadiums"),
+    endpoint="example_app:stadium-list",
+    add=MenuItem(
+        label=_("Create Stadium"),
+        endpoint="example_app:stadium-list",
+    ),
+)
+PERSONS_MENUITEM = MenuItem(
+    label=_("Persons"),
+    endpoint="example_app:person-list",
+    add=MenuItem(
+        label=_("Create Person"),
+        endpoint="example_app:person-list",
+    ),
+)
+SPORT_MENUITEM = MenuItem(
+    label=_("Sports"),
+    endpoint="example_app:sport-list",
+    add=MenuItem(
+        label=_("Create Sport"),
+        endpoint="example_app:sport-list",
+    ),
+)
+SEASON_MENUITEM = MenuItem(
+    label=_("Season"),
+    endpoint="example_app:season-list",
+    add=MenuItem(label=_("Create Season"), endpoint="example_app:season-list"),
+)
+PLAYER_MENUITEM = MenuItem(
+    label=_("Players"),
+    endpoint="example_app:player-list",
+    add=MenuItem(
+        label=_("Create Player"),
+        endpoint="example_app:player-list",
+    ),
+)
+ROLE_MENUITEM = MenuItem(
+    label=_("Roles"),
+    endpoint="example_app:role-list",
+    add=MenuItem(
+        label=_("Create Role"),
+        endpoint="example_app:role-list",
+    ),
+)
+MATCH_MENUITEM = MenuItem(
+    label=_("Matches"),
+    endpoint="example_app:match-list",
+    add=MenuItem(
+        label=_("Create Match"),
+        endpoint="example_app:match-list",
+    ),
+)
+EVENT_MENUITEM = MenuItem(
+    label=_("Events"),
+    endpoint="example_app:event-list",
+    add=MenuItem(
+        label=_("Create Event"),
+        endpoint="example_app:event-list",
+    ),
+)
+EVENTTYPE_MENUITEM = MenuItem(
+    label=_("Event Types"),
+    endpoint="example_app:eventtype-list",
+    add=MenuItem(
+        label=_("Create Event Type"),
+        endpoint="example_app:eventtype-list",
+    ),
+)
+
+EXAMPLE_APP_MENU = Menu(
+    label="Sports App",
+    items=[
+        Menu(label=_("Persons"), items=[PERSONS_MENUITEM, PLAYER_MENUITEM]),
+        ROLE_MENUITEM,
+        TEAM_MENUITEM,
+        STADIUM_MENUITEM,
+        Menu(label=_("Leagues"), items=[LEAGUE_MENUITEM, SEASON_MENUITEM]),
+        SPORT_MENUITEM,
+        MATCH_MENUITEM,
+        Menu(label=_("Events"), items=[EVENT_MENUITEM, EVENTTYPE_MENUITEM]),
+    ],
+)

wbcore/contrib/example_app/viewsets/menus.py

@@ -0,0 +1,64 @@
+from django.utils.translation import gettext_lazy as _
+
+from wbcore.menus import Menu, MenuItem
+
+TEAM_MENUITEM = MenuItem(
+    label=_("Team"),
+    endpoint="example_app:team-list",
+    add=MenuItem(
+        label=_("Create Team"),
+        endpoint="example_app:team-list",
+    ),
+)
+LEAGUE_MENUITEM = MenuItem(
+    label=_("League"),
+    endpoint="example_app:league-list",
+    add=MenuItem(
+        label=_("Create League"),
+        endpoint="example_app:league-list",
+    ),
+)
+STADIUM_MENUITEM = MenuItem(
+    label=_("Stadium"),
+    endpoint="example_app:stadium-list",
+    add=MenuItem(
+        label=_("Create Stadium"),
+        endpoint="example_app:stadium-list",
+    ),
+)
+FIGURE_MENUITEM = MenuItem(
+    label=_("Figure"),
+    endpoint="example_app:figure-list",
+    add=MenuItem(
+        label=_("Create Figure"),
+        endpoint="example_app:figure-list",
+    ),
+)
+SPORT_MENUITEM = MenuItem(
+    label=_("Sport"),
+    endpoint="example_app:sport-list",
+    add=MenuItem(
+        label=_("Create Sport"),
+        endpoint="example_app:sport-list",
+    ),
+)
+PLAYER_MENUITEM = MenuItem(
+    label=_("Player"),
+    endpoint="example_app:player-list",
+    add=MenuItem(
+        label=_("Create player"),
+        endpoint="example_app:player-list",
+    ),
+)
+
+EXAMPLE_APP_MENU = Menu(
+    label="Sports App",
+    items=[
+        FIGURE_MENUITEM,
+        PLAYER_MENUITEM,
+        TEAM_MENUITEM,
+        STADIUM_MENUITEM,
+        LEAGUE_MENUITEM,
+        SPORT_MENUITEM,
+    ],
+)

wbcore/contrib/example_app/viewsets/person.py

@@ -0,0 +1,134 @@
+from django.db.models import Avg, F, Max, Min, QuerySet, Sum
+
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import (
+    PlayerFilter,
+    PlayerTeamFilter,
+    SportPersonFilter,
+    SportPersonRepresentationFilter,
+)
+from wbcore.contrib.example_app.models import Player, SportPerson, Team
+from wbcore.contrib.example_app.serializers import (
+    PlayerModelSerializer,
+    PlayerRepresentationSerializer,
+    SportPersonModelSerializer,
+    SportPersonRepresentationSerializer,
+    SportPersonTooltipSerializer,
+    TreeViewPlayerModelSerializer,
+)
+from wbcore.contrib.example_app.viewsets.buttons import PlayerButtonConfig
+from wbcore.contrib.example_app.viewsets.displays import (
+    PlayerDisplayConfig,
+    PlayerTeamDisplayConfig,
+    SportPersonDisplayConfig,
+    SportPersonToolTipDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import PlayerTeamEndpointConfig
+from wbcore.contrib.example_app.viewsets.titles import (
+    PlayerTeamTitleConfig,
+    PlayerTitleConfig,
+    SportPersonTitleConfig,
+)
+from wbcore.utils.strings import format_number
+from wbcore.viewsets.mixins import OrderableMixin, ReparentMixin
+
+
+class SportPersonModelViewSet(viewsets.ModelViewSet):
+    display_config_class = SportPersonDisplayConfig
+    queryset = SportPerson.objects.all()
+    search_fields = ("first_name", "last_name")
+    serializer_class = SportPersonModelSerializer
+    title_config_class = SportPersonTitleConfig
+    ordering_fields = (
+        "last_name",
+        "first_name",
+        "roles__title",
+    )
+    ordering = ("last_name", "first_name")
+    filterset_class = SportPersonFilter
+
+    def get_queryset(self) -> QuerySet[SportPerson]:
+        return super().get_queryset().prefetch_related("roles")
+
+
+class SportPersonRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = SportPerson.objects.all()
+    serializer_class = SportPersonRepresentationSerializer
+    search_fields = ("computed_str",)
+    filterset_class = SportPersonRepresentationFilter
+
+
+class SportPersonToolTipViewset(viewsets.ModelViewSet):
+    IDENTIFIER = "example_app:persontooltip"
+    queryset = SportPerson.objects.all()
+    display_config_class = SportPersonToolTipDisplayConfig
+    serializer_class = SportPersonTooltipSerializer
+    title_config_class = SportPersonTitleConfig
+
+
+class PlayerModelViewSet(SportPersonModelViewSet):
+    display_config_class = PlayerDisplayConfig
+    queryset = Player.objects.all()
+    search_fields = SportPersonModelViewSet.search_fields + ("current_team__name",)
+    serializer_class = PlayerModelSerializer
+    title_config_class = PlayerTitleConfig
+    ordering_fields = SportPersonModelViewSet.ordering_fields + (
+        "position",
+        "current_team__name",
+        "former_teams__name",
+        "transfer_value",
+    )
+    ordering = ("last_name", "first_name", "current_team__name", "id")
+    filterset_class = PlayerFilter
+    button_config_class = PlayerButtonConfig
+
+    def get_aggregates(self, queryset: QuerySet[Player], paginated_queryset: QuerySet[Player]):
+        transfer_sum = queryset.aggregate(s=Sum(F("transfer_value")))["s"] or 0
+        transfer_average = queryset.aggregate(a=Avg(F("transfer_value")))["a"] or 0
+        transfer_max = queryset.aggregate(m=Max(F("transfer_value")))["m"] or 0
+        transfer_min = queryset.aggregate(m=Min(F("transfer_value")))["m"] or 0
+        return {
+            "transfer_value": {
+                "Σ": format_number(transfer_sum),
+                "⌀": format_number(transfer_average),
+                "Max": format_number(transfer_max),
+                "Min": format_number(transfer_min),
+            }
+        }
+
+    def get_queryset(self) -> QuerySet[Player]:
+        return super().get_queryset().select_related("current_team").prefetch_related("former_teams")
+
+
+class PlayerRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Player.objects.all()
+    serializer_class = PlayerRepresentationSerializer
+    search_fields = ("computed_str",)
+
+
+class PlayerTeamModelViewSet(PlayerModelViewSet):
+    display_config_class = PlayerTeamDisplayConfig
+    ordering_fields = SportPersonModelViewSet.ordering_fields + (
+        "position",
+        "former_teams__name",
+        "transfer_value",
+    )
+    ordering = ("last_name", "first_name", "id")
+    filterset_class = PlayerTeamFilter
+    title_config_class = PlayerTeamTitleConfig
+    endpoint_config_class = PlayerTeamEndpointConfig
+
+    def get_queryset(self) -> QuerySet[Player]:
+        queryset = super().get_queryset()
+        if team_id := self.kwargs.get("team_id"):
+            queryset = queryset.filter(current_team=team_id)
+        return queryset
+
+
+class TreeViewPlayerModelViewSet(OrderableMixin, ReparentMixin, viewsets.ModelViewSet):
+    PARENT_FIELD = "current_team"
+    PARENT_MODEL = Team
+    ordering = ("order", "computed_str", "id")
+    filterset_class = PlayerFilter
+    queryset = Player.objects.all()
+    serializer_class = TreeViewPlayerModelSerializer

wbcore/contrib/example_app/viewsets/role.py

@@ -0,0 +1,25 @@
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import RoleFilter
+from wbcore.contrib.example_app.models import Role
+from wbcore.contrib.example_app.serializers import (
+    RoleModelSerializer,
+    RoleRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import RoleDisplayConfig
+from wbcore.contrib.example_app.viewsets.titles import RoleTitleConfig
+
+
+class RoleModelViewSet(viewsets.ModelViewSet):
+    display_config_class = RoleDisplayConfig
+    queryset = Role.objects.all()
+    serializer_class = RoleModelSerializer
+    title_config_class = RoleTitleConfig
+    ordering_fields = ordering = ("title",)
+    filterset_class = RoleFilter
+    search_fields = ("title",)
+
+
+class RoleRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Role.objects.all()
+    serializer_class = RoleRepresentationSerializer
+    search_fields = ("title",)

wbcore/contrib/example_app/viewsets/season.py

@@ -0,0 +1,23 @@
+from wbcore import viewsets
+from wbcore.contrib.example_app.models import Season
+from wbcore.contrib.example_app.serializers import (
+    SeasonModelSerializer,
+    SeasonRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import SeasonDisplayConfig
+
+
+class SeasonModelViewSet(viewsets.ModelViewSet):
+    display_config_class = SeasonDisplayConfig
+    queryset = Season.objects.all()
+    search_fields = ("name", "winner")
+    serializer_class = SeasonModelSerializer
+    ordering_fields = ("name", "winner", "top_scorer", "start_date", "end_date")
+    ordering = ("name", "id")
+    filterset_fields = ("name", "winner")
+
+
+class SeasonRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Season.objects.all()
+    serializer_class = SeasonRepresentationSerializer
+    search_fields = ("name",)

wbcore/contrib/example_app/viewsets/sport.py

@@ -0,0 +1,26 @@
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import SportFilter
+from wbcore.contrib.example_app.models import Sport
+from wbcore.contrib.example_app.serializers import (
+    SportModelSerializer,
+    SportRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import SportDisplayConfig
+from wbcore.contrib.example_app.viewsets.titles import SportTitleConfig
+
+
+class SportModelViewSet(viewsets.ModelViewSet):
+    display_config_class = SportDisplayConfig
+    queryset = Sport.objects.all()
+    search_fields = ("name",)
+    serializer_class = SportModelSerializer
+    title_config_class = SportTitleConfig
+    ordering_fields = ("name", "rules", "match_duration")
+    ordering = ("name", "id")
+    filterset_class = SportFilter
+
+
+class SportRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Sport.objects.all()
+    serializer_class = SportRepresentationSerializer
+    search_fields = ("name",)

wbcore/contrib/example_app/viewsets/stadium.py

@@ -0,0 +1,31 @@
+from django.db.models import QuerySet
+
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import StadiumFilter
+from wbcore.contrib.example_app.models import Stadium
+from wbcore.contrib.example_app.serializers import (
+    StadiumModelSerializer,
+    StadiumRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import StadiumDisplayConfig
+from wbcore.contrib.example_app.viewsets.titles import StadiumTitleConfig
+
+
+class StadiumModelViewSet(viewsets.ModelViewSet):
+    display_config_class = StadiumDisplayConfig
+    queryset = Stadium.objects.all()
+    search_fields = ("name", "city__representation")
+    serializer_class = StadiumModelSerializer
+    title_config_class = StadiumTitleConfig
+    ordering_fields = ("name", "city__representation", "capacity")
+    ordering = ("name", "city__representation")
+    filterset_class = StadiumFilter
+
+    def get_queryset(self) -> QuerySet[Stadium]:
+        return super().get_queryset().select_related("city")
+
+
+class StadiumRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Stadium.objects.all()
+    serializer_class = StadiumRepresentationSerializer
+    search_fields = ("name",)

wbcore/contrib/example_app/viewsets/team.py

@@ -0,0 +1,69 @@
+from django.db.models import F, QuerySet
+
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import TeamFilter, TeamStadiumFilter
+from wbcore.contrib.example_app.models import Team
+from wbcore.contrib.example_app.serializers import (
+    TeamModelSerializer,
+    TeamRepresentationSerializer,
+)
+from wbcore.contrib.example_app.viewsets.buttons import TeamButtonConfig
+from wbcore.contrib.example_app.viewsets.displays import (
+    TeamDisplayConfig,
+    TeamStadiumDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import TeamStadiumEndpointConfig
+from wbcore.contrib.example_app.viewsets.titles import (
+    TeamStadiumTitleConfig,
+    TeamTitleConfig,
+)
+from wbcore.viewsets.mixins import OrderableMixin
+
+
+class TeamModelViewSet(OrderableMixin, viewsets.ModelViewSet):
+    button_config_class = TeamButtonConfig
+    display_config_class = TeamDisplayConfig
+    title_config_class = TeamTitleConfig
+
+    queryset = Team.objects.all()
+    search_fields = ("name", "city__representation")
+    serializer_class = TeamModelSerializer
+    ordering_fields = (
+        "name",
+        "city__representation",
+        "founded_date",
+        "coach__computed_str",
+        "home_stadium__name",
+    )
+    ordering = ("order", "name")
+    filterset_class = TeamFilter
+
+    def get_queryset(self) -> QuerySet[Team]:
+        return (
+            super()
+            .get_queryset()
+            .annotate(_group_key=F("id"))
+            .select_related("city", "coach", "home_stadium")
+            .prefetch_related("opponents")
+        )
+
+
+class TeamStadiumModelViewSet(TeamModelViewSet):
+    display_config_class = TeamStadiumDisplayConfig
+    ordering_fields = ("name", "city__representation", "founded_date", "coach__computed_str")
+    filterset_class = TeamStadiumFilter
+    endpoint_config_class = TeamStadiumEndpointConfig
+    title_config_class = TeamStadiumTitleConfig
+
+    def get_queryset(self) -> QuerySet[Team]:
+        queryset = super().get_queryset()
+        if stadium_id := self.kwargs.get("stadium_id"):
+            queryset = queryset.filter(home_stadium=stadium_id)
+        return queryset
+
+
+class TeamRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Team.objects.all()
+    serializer_class = TeamRepresentationSerializer
+    search_fields = ("name",)
+    filterset_class = TeamFilter