wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/example_app/tests/e2e/test_person.py

@@ -0,0 +1,67 @@
+import pytest
+from selenium.webdriver.common.action_chains import ActionChains
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.example_app.models import SportPerson
+from wbcore.contrib.example_app.serializers import SportPersonModelSerializer
+from wbcore.contrib.example_app.tests.e2e import create_new_person_instance
+from wbcore.test import (
+    click_element_by_path,
+    click_new_button,
+    delete_list_entry,
+    edit_list_instance,
+    is_counter_as_expected,
+    is_string_not_visible,
+    is_text_visible,
+    open_menu_item,
+    set_up,
+)
+
+USER_PASSWORD = "User_Password"
+
+
+@pytest.mark.skip(reason="no way of currently testing this")
+@pytest.mark.django_db
+class TestPerson:
+    def test_create_edit_delete_person(self, live_server, selenium):
+        # Creating a test user and login to the WB
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)
+        actions = ActionChains(selenium, 1000)
+        set_up(selenium, live_server, user.email, USER_PASSWORD)
+
+        # -----> CREATE A NEW PERSON <----- #
+        person_a = create_new_person_instance(selenium, ["first_name", "last_name"], False)
+        open_menu_item(selenium, "Persons")
+        # TODO find a solution how to handle the case, that a navigation element has the same name as a subelement.
+        click_element_by_path(selenium, '//div[@title="Persons"]')
+        click_element_by_path(selenium, '//span[@title="Create Person"]//parent::div//div')
+
+        window_width = (selenium.get_window_size().get("width")) / 1.75
+        actions.move_by_offset(window_width, 0).perform()
+        actions.click()
+
+        assert is_counter_as_expected(selenium, SportPerson.objects.count())
+        assert is_text_visible(selenium, person_a.last_name)
+
+        click_new_button(selenium)
+        assert is_text_visible(selenium, "Create Person")
+        person_b = create_new_person_instance(selenium, ["first_name", "last_name"])
+
+        assert is_counter_as_expected(selenium, SportPerson.objects.count())
+        assert is_text_visible(selenium, person_b.last_name)
+
+        # ------> EDIT A NEW PERSON <------ #
+
+        edit_list_instance(
+            selenium, actions, person_a.last_name, SportPersonModelSerializer(person_a), {"last_name": "Foobar"}
+        )
+        assert is_string_not_visible(selenium, person_a.last_name)
+        assert is_text_visible(selenium, "Foobar")
+        assert is_counter_as_expected(selenium, SportPerson.objects.count())
+
+        # -----> Delete <----- #
+
+        delete_list_entry(selenium, actions, person_b.last_name)
+        assert is_counter_as_expected(selenium, SportPerson.objects.count())
+        assert is_text_visible(selenium, "Foobar")
+        assert is_string_not_visible(selenium, person_b.last_name)

wbcore/contrib/example_app/tests/e2e/test_teams.py

@@ -0,0 +1,56 @@
+import pytest
+from selenium.webdriver.common.action_chains import ActionChains
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.example_app.models import Team
+from wbcore.contrib.example_app.serializers import TeamModelSerializer
+from wbcore.contrib.example_app.tests.e2e import create_new_team_instance
+from wbcore.test import (
+    click_new_button,
+    delete_list_entry,
+    edit_list_instance,
+    is_counter_as_expected,
+    is_string_not_visible,
+    is_text_visible,
+    open_menu_item,
+    set_up,
+)
+
+USER_PASSWORD = "User_Password"
+
+
+@pytest.mark.skip(reason="no way of currently testing this")
+@pytest.mark.django_db
+class TestTeam:
+    def test_create_edit_delete_team(self, live_server, selenium):
+        # Creating a test user and login to the WB
+        user: User = SuperUserFactory(plaintext_password=USER_PASSWORD)
+        actions = ActionChains(selenium, 1000)
+        set_up(selenium, live_server, user.email, USER_PASSWORD)
+
+        # -----> CREATE A NEW TEAM <----- #
+        team_a = create_new_team_instance(selenium, ["name", "founded_date"], False)
+        open_menu_item(selenium, "Teams", perform_mouse_move=True)
+
+        assert is_counter_as_expected(selenium, Team.objects.count())
+        assert is_text_visible(selenium, team_a.name)
+        click_new_button(selenium)
+        assert is_text_visible(selenium, "Create Team")
+        team_b = create_new_team_instance(selenium, ["name", "founded_date"], True)
+
+        assert is_counter_as_expected(selenium, Team.objects.count())
+        assert is_text_visible(selenium, team_b.name)
+
+        # ------> EDIT A NEW LEAGUE <------ #
+
+        edit_list_instance(selenium, actions, team_a.name, TeamModelSerializer(team_a), {"name": "Fun Team"})
+        assert is_string_not_visible(selenium, team_a.name)
+        assert is_text_visible(selenium, "Fun Team")
+        assert is_counter_as_expected(selenium, Team.objects.count())
+
+        # -----> Delete <----- #
+
+        delete_list_entry(selenium, actions, team_b.name)
+        assert is_counter_as_expected(selenium, Team.objects.count())
+        assert is_text_visible(selenium, "Fun Team")
+        assert is_string_not_visible(selenium, team_b.name)

wbcore/contrib/example_app/tests/signals.py

@@ -0,0 +1,7 @@
+from django.db import connection
+
+
+def app_pre_migration(sender, app_config, **kwargs):
+    cur = connection.cursor()
+    cur.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gin;")

wbcore/contrib/example_app/tests/test_displays.py

@@ -0,0 +1,40 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.example_app.models import Match
+from wbcore.contrib.example_app.viewsets.displays.match import (
+    get_match_status_formatting,
+    get_match_status_legend,
+)
+
+
+@pytest.mark.django_db
+class TestMatch:
+    @patch("wbcore.contrib.example_app.models.Match.MatchStatus.get_color_map")
+    def test_get_match_status_legend(self, mock_color_map):
+        mock_color_map.return_value = [
+            (Match.MatchStatus.FINISHED, "firstcolor"),
+            (Match.MatchStatus.ONGOING, "secondcolor"),
+            (Match.MatchStatus.SCHEDULED, "lastcolor"),
+        ]
+        assert [(y.icon, y.label, y.value) for y in get_match_status_legend()[0].items] == [
+            ("firstcolor", Match.MatchStatus.FINISHED.label, Match.MatchStatus.FINISHED.value),
+            ("secondcolor", Match.MatchStatus.ONGOING.label, Match.MatchStatus.ONGOING.value),
+            ("lastcolor", Match.MatchStatus.SCHEDULED.label, Match.MatchStatus.SCHEDULED.value),
+        ]
+        assert mock_color_map.called
+
+    @patch("wbcore.contrib.example_app.models.Match.MatchStatus.get_color_map")
+    def test_get_match_status_formatting(self, mock_color_map):
+        mock_color_map.return_value = [
+            (Match.MatchStatus.ONGOING, "firstcolor"),
+            (Match.MatchStatus.SCHEDULED, "secondcolor"),
+            (Match.MatchStatus.FINISHED, "lastcolor"),
+        ]
+        assert [
+            (y.style["backgroundColor"], y.condition[1]) for y in get_match_status_formatting()[0].formatting_rules
+        ] == [
+            ("firstcolor", Match.MatchStatus.ONGOING.value),
+            ("secondcolor", Match.MatchStatus.SCHEDULED.value),
+            ("lastcolor", Match.MatchStatus.FINISHED.value),
+        ]

wbcore/contrib/example_app/tests/test_filters.py

@@ -0,0 +1,70 @@
+from datetime import timedelta
+from unittest.mock import patch
+
+import pytest
+from django.utils import timezone
+from psycopg.types.range import DateRange
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.example_app.factories import (
+    EventFactory,
+    MatchFactory,
+    PlayerFactory,
+    SportPersonFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.viewsets import (
+    PlayerStatisticsChartModelViewSet,
+    SportPersonRepresentationViewSet,
+)
+from wbcore.filters.defaults import current_year_date_range
+from wbcore.test.utils import get_or_create_superuser
+
+
+@pytest.mark.django_db
+class TestEvent:
+    @patch("wbcore.contrib.example_app.models.Match.reschedule_task")
+    def test_filter_by_period(self, mock_reschedule):
+        event = EventFactory(match__date_time=timezone.now())
+        before_event = DateRange((timezone.now() - timedelta(7)).date(), (timezone.now() - timedelta(1)).date())
+        after_event = DateRange((timezone.now() + timedelta(1)).date(), (timezone.now() + timedelta(7)).date())
+        mvs = PlayerStatisticsChartModelViewSet(kwargs={"player_id": event.person})
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert len(mvs.filterset_class(request=request).filter_by_period(qs, "", current_year_date_range())) == 1
+        assert (
+            mvs.filterset_class(request=request).filter_by_period(qs, "", current_year_date_range()).first() == event
+        )
+        assert not mvs.filterset_class(request=request).filter_by_period(qs, "", before_event).exists()
+        assert not mvs.filterset_class(request=request).filter_by_period(qs, "", after_event).exists()
+
+
+@pytest.mark.django_db
+class TestPerson:
+    @patch("wbcore.contrib.example_app.models.Match.reschedule_task")
+    def test_filter_by_match(self, mock_reschedule):
+        ref1 = SportPersonFactory()
+        match1 = MatchFactory(referee=ref1, home__coach=None, away__coach=None)
+        ref2 = SportPersonFactory()
+        home_coach = SportPersonFactory()
+        away_coach = SportPersonFactory()
+        home_team = TeamFactory(coach=home_coach)
+        away_team = TeamFactory(coach=away_coach)
+        home_player = PlayerFactory(current_team=home_team)
+        away_player = PlayerFactory(current_team=away_team)
+        match2 = MatchFactory(
+            home=home_team,
+            away=away_team,
+            referee=ref2,
+        )
+        SportPersonFactory()
+        PlayerFactory()
+        mvs = SportPersonRepresentationViewSet()
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        qs = mvs.get_queryset()
+        assert len(mvs.filterset_class(request=request).filter_by_match(qs, "", match1)) == 1
+        assert mvs.filterset_class(request=request).filter_by_match(qs, "", match1).first() == ref1
+        assert set(
+            mvs.filterset_class(request=request).filter_by_match(qs, "", match2).values_list("id", flat=True)
+        ) == {ref2.pk, home_coach.pk, away_coach.pk, home_player.pk, away_player.pk}

wbcore/contrib/example_app/tests/test_utils.py

@@ -0,0 +1,25 @@
+import pytest
+from wbcore.contrib.example_app.factories import (
+    EventFactory,
+    EventTypeFactory,
+    LeagueFactory,
+)
+from wbcore.contrib.example_app.utils import get_event_types_for_league
+
+
+@pytest.mark.django_db
+class TestUtils:
+    def test_get_event_types_for_league(self):
+        league = LeagueFactory()
+        event_type1 = EventTypeFactory(sport=league.sport)
+        event_type2 = EventTypeFactory(sport=league.sport)
+        event_type3 = EventTypeFactory()
+        event_type4 = EventTypeFactory(sport=league.sport)
+        EventFactory(event_type=event_type1)
+        EventFactory(event_type=event_type2)
+        EventFactory(event_type=event_type3)
+        league_event_types = get_event_types_for_league(league.pk)
+        for event_type in league_event_types:
+            assert event_type["name"] in [event_type1.name, event_type2.name]
+            assert event_type["name"] not in [event_type3.name, event_type4.name]
+            assert " " not in event_type["slugified_name"]

wbcore/contrib/example_app/urls.py

@@ -0,0 +1,79 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from . import viewsets
+
+router = WBCoreRouter()
+
+router.register(r"league", viewsets.LeagueModelViewSet, basename="league")
+router.register(r"player", viewsets.PlayerModelViewSet, basename="player")
+router.register(r"treeviewplayer", viewsets.TreeViewPlayerModelViewSet, basename="treeviewplayer")
+router.register(r"person", viewsets.SportPersonModelViewSet, basename="person")
+router.register(r"persontooltip", viewsets.SportPersonToolTipViewset, basename="persontooltip")
+router.register(r"stadium", viewsets.StadiumModelViewSet, basename="stadium")
+router.register(r"season", viewsets.SeasonModelViewSet, basename="season")
+router.register(r"team", viewsets.TeamModelViewSet, basename="team")
+router.register(r"sport", viewsets.SportModelViewSet, basename="sport")
+router.register(r"role", viewsets.RoleModelViewSet, basename="role")
+router.register(r"match", viewsets.MatchModelViewSet, basename="match")
+router.register(r"event", viewsets.EventModelViewSet, basename="event")
+router.register(r"eventtype", viewsets.EventTypeModelViewSet, basename="eventtype")
+router.register(r"teamresults", viewsets.TeamResultsModelViewSet, basename="teamresults")
+
+router.register(r"personrepresentation", viewsets.SportPersonRepresentationViewSet, basename="personrepresentation")
+router.register(r"stadiumrepresentation", viewsets.StadiumRepresentationViewSet, basename="stadiumrepresentation")
+router.register(r"seasonrepresentation", viewsets.SeasonRepresentationViewSet, basename="seasonrepresentation")
+router.register(r"leaguerepresentation", viewsets.LeagueRepresentationViewSet, basename="leaguerepresentation")
+router.register(r"sportrepresentation", viewsets.SportRepresentationViewSet, basename="sportrepresentation")
+router.register(r"teamrepresentation", viewsets.TeamRepresentationViewSet, basename="teamrepresentation")
+router.register(r"rolerepresentation", viewsets.RoleRepresentationViewSet, basename="rolerepresentation")
+router.register(r"playerrepresentation", viewsets.PlayerRepresentationViewSet, basename="playerrepresentation")
+router.register(r"matchrepresentation", viewsets.MatchRepresentationViewSet, basename="matchrepresentation")
+router.register(r"eventrepresentation", viewsets.EventRepresentationViewSet, basename="eventrepresentation")
+router.register(
+    r"eventtyperepresentation", viewsets.EventTypeRepresentationViewSet, basename="eventtyperepresentation"
+)
+router.register(
+    r"teamresultsrepresentation", viewsets.TeamResultsRepresentationViewSet, basename="teamresultsrepresentation"
+)
+
+stadium_router = WBCoreRouter()
+stadium_router.register(r"team-stadium", viewsets.TeamStadiumModelViewSet, basename="team-stadium")
+stadium_router.register(r"match-stadium", viewsets.MatchStadiumModelViewSet, basename="match-stadium")
+
+sport_router = WBCoreRouter()
+sport_router.register(r"league-sport", viewsets.LeagueSportModelViewSet, basename="league-sport")
+sport_router.register(r"eventtype-sport", viewsets.EventTypeSportModelViewSet, basename="eventtype-sport")
+
+team_router = WBCoreRouter()
+team_router.register(r"player-team", viewsets.PlayerTeamModelViewSet, basename="player-team")
+team_router.register(r"match-team", viewsets.MatchModelViewSet, basename="match-team")
+
+match_router = WBCoreRouter()
+match_router.register(r"event-match", viewsets.EventMatchModelViewSet, basename="event-match")
+
+league_router = WBCoreRouter()
+league_router.register(r"match-league", viewsets.MatchLeagueModelViewSet, basename="match-league")
+league_router.register(r"teamresults-league", viewsets.TeamResultsLeagueModelViewSet, basename="teamresults-league")
+
+league_event_type_router = WBCoreRouter()
+league_event_type_router.register(
+    r"league-player-statistics", viewsets.LeaguePlayerStatisticsModelViewSet, basename="league-player-statistics"
+)
+league_event_type_router.register(
+    r"league-team-statistics", viewsets.LeagueTeamStatisticsModelViewSet, basename="league-team-statistics"
+)
+
+player_router = WBCoreRouter()
+player_router.register(r"player-statistics", viewsets.PlayerStatisticsChartModelViewSet, basename="player-statistics")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("stadium/<int:stadium_id>/", include(stadium_router.urls)),
+    path("sport/<int:sport_id>/", include(sport_router.urls)),
+    path("team/<int:team_id>/", include(team_router.urls)),
+    path("match/<int:match_id>/", include(match_router.urls)),
+    path("league/<int:league_id>/", include(league_router.urls)),
+    path("league/<int:league_id>/event_type/<int:event_type_id>/", include(league_event_type_router.urls)),
+    path("player/<int:player_id>/", include(player_router.urls)),
+]

wbcore/contrib/example_app/utils.py

@@ -0,0 +1,20 @@
+from slugify import slugify
+from wbcore.contrib.example_app.models import EventType
+
+
+def get_event_types_for_league(league_id: int) -> list[dict[str, int | str]]:
+    """Retrieves all event types involved inside a league
+
+    Args:
+        league_id (str): ID of the league in question
+
+    Returns:
+        list[dict[int,str, str]]: A list of dictionaries with the event type's id, name and slugified name
+    """
+
+    event_types = (
+        EventType.objects.filter(sport__leagues=league_id, events__isnull=False).distinct().values("id", "name")
+    )
+    for event_type in event_types:
+        event_type["slugified_name"] = slugify(event_type["name"], separator="_")
+    return event_types

wbcore/contrib/example_app/viewsets/__init__.py

@@ -0,0 +1,29 @@
+from .person import (
+    SportPersonModelViewSet,
+    SportPersonRepresentationViewSet,
+    PlayerModelViewSet,
+    PlayerTeamModelViewSet,
+    PlayerRepresentationViewSet,
+    TreeViewPlayerModelViewSet,
+    SportPersonToolTipViewset,
+)
+from .league import LeagueModelViewSet, LeagueRepresentationViewSet, LeagueSportModelViewSet
+from .stadium import StadiumModelViewSet, StadiumRepresentationViewSet
+from .team import TeamModelViewSet, TeamRepresentationViewSet, TeamStadiumModelViewSet
+from .sport import SportModelViewSet, SportRepresentationViewSet
+from .role import RoleModelViewSet, RoleRepresentationViewSet
+from .league import LeagueModelViewSet
+from .match import MatchModelViewSet, MatchRepresentationViewSet, MatchStadiumModelViewSet, MatchLeagueModelViewSet
+from .event import (
+    EventModelViewSet,
+    EventRepresentationViewSet,
+    EventTypeRepresentationViewSet,
+    EventTypeModelViewSet,
+    EventTypeSportModelViewSet,
+    EventMatchModelViewSet,
+    PlayerStatisticsChartModelViewSet,
+    LeaguePlayerStatisticsModelViewSet,
+    LeagueTeamStatisticsModelViewSet,
+)
+from .teamresult import TeamResultsModelViewSet, TeamResultsRepresentationViewSet, TeamResultsLeagueModelViewSet
+from .season import SeasonModelViewSet, SeasonRepresentationViewSet

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

@@ -0,0 +1,2 @@
+from .person import PlayerButtonConfig
+from .team import TeamButtonConfig

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

@@ -0,0 +1,18 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class PlayerButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self) -> set:
+        if player_id := self.view.kwargs.get("pk"):
+            return {
+                bt.WidgetButton(
+                    label=_("Statistics"),
+                    icon=WBIcon.TABLE.icon,
+                    endpoint=reverse("example_app:player-statistics-list", args=[player_id], request=self.request),
+                ),
+            }
+        return set()

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

@@ -0,0 +1,23 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class TeamButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self) -> set:
+        return {
+            bt.DropDownButton(
+                label=_("Website & Coach"),
+                icon=WBIcon.UNFOLD.icon,
+                buttons=(
+                    bt.HyperlinkButton(key="website", label=_("Homepage"), icon=WBIcon.LINK.icon, weight=1),
+                    bt.WidgetButton(
+                        label=_("Coach"),
+                        icon=WBIcon.PERSON.icon,
+                        key="coach",
+                        weight=2,
+                    ),
+                ),
+            )
+        }

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

@@ -0,0 +1,23 @@
+from .person import (
+    SportPersonDisplayConfig,
+    PlayerDisplayConfig,
+    PlayerTeamDisplayConfig,
+    TreeViewPlayerDisplay,
+    SportPersonToolTipDisplayConfig,
+)
+from .league import LeagueDisplayConfig, LeagueSportDisplayConfig
+from .team import TeamDisplayConfig, TeamStadiumDisplayConfig
+from .stadium import StadiumDisplayConfig
+from .sport import SportDisplayConfig
+from .season import SeasonDisplayConfig
+from .role import RoleDisplayConfig
+from .match import MatchDisplayConfig, MatchStadiumDisplayConfig, MatchLeagueDisplayConfig
+from .event import (
+    EventDisplayConfig,
+    EventTypeDisplayConfig,
+    EventTypeSportDisplayConfig,
+    EventMatchDisplayConfig,
+    LeaguePlayerStatisticsDisplayConfig,
+    LeagueTeamStatisticsDisplayConfig,
+)
+from .teamresult import TeamResultsDisplayConfig, TeamResultsLeagueDisplayConfig

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

@@ -0,0 +1,186 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display import Display, Layout, Page, Style
+from wbcore.metadata.configs.display.instance_display.operators import default, lte
+from wbcore.metadata.configs.display.list_display import ListDisplay
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+EVENT_TYPE_FIELDS = [
+    dp.Field(key="name", label=_("Name")),
+    dp.Field(key="sport", label=_("Sport")),
+    dp.Field(key="points", label=_("Points")),
+    dp.Field(key="icon", label=_("Icon")),
+    dp.Field(key="color", label=_("Color")),
+]
+EVENT_FIELDS = [
+    dp.Field(key="match", label=_("Match")),
+    dp.Field(key="event_type", label=_("Event Type")),
+    dp.Field(key="person", label=_("Person")),
+    dp.Field(key="minute", label=_("Minute")),
+]
+
+
+class EventDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(fields=EVENT_FIELDS)
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["match", "event_type"],
+                                ["person", "minute"],
+                                ["event_description", "event_description"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(650): Layout(
+                            grid_template_areas=[
+                                ["match"],
+                                ["event_type"],
+                                ["person"],
+                                ["minute"],
+                                ["event_description"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ]
+        )
+
+
+class LeaguePlayerStatisticsDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(
+            fields=(dp.Field(key="person_name", label=_("Person")), dp.Field(key="count", label=_(" "))),
+        )
+
+
+class LeagueTeamStatisticsDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(
+            fields=(dp.Field(key="team_name", label=_("Team")), dp.Field(key="count", label=_(" "))),
+        )
+
+
+class EventMatchDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        fields = EVENT_FIELDS.copy()
+        fields.pop(0)
+        return dp.ListDisplay(fields=fields)
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["event_type", "person", "minute"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(800): Layout(
+                            grid_template_areas=[
+                                ["event_type", "."],
+                                ["person", "minute"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(3),
+                        ),
+                        lte(450): Layout(
+                            grid_template_areas=[
+                                ["event_type"],
+                                ["person"],
+                                ["minute"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ]
+        )
+
+
+class EventTypeDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(fields=EVENT_TYPE_FIELDS)
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["name", "sport"],
+                                ["points", "icon"],
+                                ["color", "color"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(650): Layout(
+                            grid_template_areas=[
+                                ["name"],
+                                ["sport"],
+                                ["points"],
+                                ["icon"],
+                                ["color"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ]
+        )
+
+
+class EventTypeSportDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        fields = EVENT_TYPE_FIELDS.copy()
+        fields.pop(1)
+        return dp.ListDisplay(fields=fields)
+
+    def get_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["name", "points"],
+                                ["icon", "color"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(650): Layout(
+                            grid_template_areas=[
+                                ["name"],
+                                ["sport"],
+                                ["points"],
+                                ["icon"],
+                                ["color"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ]
+        )