wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/example_app/tests/test_viewsets/test_teamresult_viewset.py

@@ -0,0 +1,58 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import TeamResultsFactory
+from wbcore.contrib.example_app.serializers import TeamResultsModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import TeamResultsModelViewSet
+
+
+@pytest.mark.django_db
+class TestTeamResultsModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory.create()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:teamresults-list")
+        self.detail_url_str = "example_app:teamresults-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        team_result = TeamResultsFactory.create()
+        response = get_create_view(self.client, team_result, self.user, self.list_url, TeamResultsModelViewSet)
+        # It is not possible to create an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)
+
+    def test_detail_view(self):
+        instance = TeamResultsFactory.create()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["id"], instance.id)
+
+    def test_update_view(self):
+        instance = TeamResultsFactory.create()
+        instance.points = 5
+        response = get_update_view(self.client, instance, TeamResultsModelSerializer, self.detail_url_str)
+        # It is not possible to update an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)
+
+    def test_partial_update_view(self):
+        instance = TeamResultsFactory.create()
+        response = get_partial_view(self.client, instance.id, {"points": 5}, self.detail_url_str)
+        self.assertEqual(response.status_code, 405)
+
+    def test_delete_view(self):
+        instance = TeamResultsFactory.create()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        # It is not possible to delete an team results, since the get_endpoint_url returns None.
+        self.assertEqual(response.status_code, 405)

wbcore/contrib/example_app/tests/test_viewsets/test_utils_viewsets.py

@@ -0,0 +1,124 @@
+from django.db.models import Model
+from django.http import HttpResponse
+from django.test import Client
+from django.urls import reverse
+from wbcore.contrib.authentication.models import User
+from wbcore.serializers import Serializer
+from wbcore.test.utils import get_data_from_factory
+from wbcore.viewsets import ModelViewSet
+
+
+def get_create_view(
+    client: Client,
+    instance: Model,
+    superuser: User,
+    url: str,
+    viewset: ModelViewSet,
+) -> HttpResponse:
+    """
+    Create a new instance through a view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance (django.db.models.Model): The model instance to be created.
+        - superuser (django.contrib.auth.models.User): The superuser for authentication.
+        - url (str): The URL endpoint for the view.
+        - viewset (wbcore.viewsets.ModelViewSet): The viewset for the model.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the view.
+    """
+    instance_data = get_data_from_factory(instance, viewset, delete=True, superuser=superuser)
+    return client.post(url, instance_data)
+
+
+def get_detail_view(client: Client, pk: int, url: str) -> HttpResponse:
+    """
+    Retrieve the details of a model instance through a detail view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - pk (int): The primary key of the model instance to retrieve.
+        - url (str): The base URL endpoint for the detail view.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the detail view.
+    """
+    detail_url = reverse(url, args=[pk])
+    return client.get(detail_url)
+
+
+def get_update_view(client: Client, instance: Model, serializer: Serializer, url: str) -> HttpResponse:
+    """
+    Update a model instance through an update view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance (django.db.models.Model): The model instance to be updated.
+        - serializer (Serializer): The serializer used to serialize the instance.
+        - url (str): The base URL endpoint for the update view.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the update view.
+    """
+    update_url = reverse(url, args=[instance.pk])
+    serialized_data = serializer(instance).data
+    return client.put(update_url, data=serialized_data, content_type="application/json")
+
+
+def get_partial_view(client: Client, instance_id: int, data: dict, url: str) -> HttpResponse:
+    """
+    Facilitates partial updates to a specific instance of a model using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - instance_id (int): The unique identifier (primary key) of the instance to be partially updated.
+        - data (dict): A dictionary containing the fields and their respective new values that need to be updated in the instance.
+        - url (str): The base URL endpoint for the patch view.
+    Returns:
+        django.http.HttpResponse: The HTTP response from the patch view.
+    """
+    update_url = reverse(url, args=[instance_id])
+    return client.patch(update_url, data=data, content_type="application/json")
+
+
+def get_delete_view(client: Client, url: str, pk: int) -> HttpResponse:
+    """
+    Delete a model instance through a delete view using the Django REST Framework client.
+
+    Parameters:
+        - client (django.test.Client): The Django test client.
+        - url (str): The base URL endpoint for the delete view.
+        - pk (int): The primary key of the model instance to delete.
+
+    Returns:
+        django.http.HttpResponse: The HTTP response from the delete view.
+    """
+    delete_url = reverse(url, args=[pk])
+    return client.delete(delete_url)
+
+
+def find_instances_in_response(instances: list[Model], response: HttpResponse) -> tuple:
+    """
+    Find instances in the data contained in an HTTP response.
+
+    This method takes a list of instances and an HTTP response object, and it checks if each instance
+    is present in the data of the response based on their unique identifier (e.g., 'id').
+
+    Parameters:
+        - instances (list): A list of instances (models) to search for in the response data.
+        - response (HttpResponse): An HTTP response object containing data to search within.
+
+    Returns:
+        tuple: A tuple of Boolean values indicating whether each instance was found in the response.
+            Each element in the tuple corresponds to an instance in the same order as in the 'instances' list.
+            If an instance is found, the corresponding value is True; otherwise, it is False.
+    """
+    found_instances = [False] * len(instances)
+
+    for item in response.data["results"]:
+        for index, instance in enumerate(instances):
+            if item.get("id") == instance.id:
+                found_instances[index] = True
+
+    return tuple(found_instances)

wbcore/contrib/example_app/urls.py

@@ -0,0 +1,82 @@
+from django.urls import include, path
+
+from wbcore.contrib.example_app.views import embedded_view_example
+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)),
+    path("embedded/", embedded_view_example),
+]

wbcore/contrib/example_app/utils.py

@@ -0,0 +1,21 @@
+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/views.py

@@ -0,0 +1,6 @@
+from django.http import HttpRequest, HttpResponse
+from django.shortcuts import render
+
+
+def embedded_view_example(request: HttpRequest) -> HttpResponse:
+    return render(request, "example_app/embedded_view.html")

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,19 @@
+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,24 @@
+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,187 @@
+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,
+                        ),
+                    },
+                ),
+            ]
+        )