wbcore 2.2.1__py2.py3-none-any.whl

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

@@ -0,0 +1,230 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display import (
+    Display,
+    Inline,
+    Layout,
+    Page,
+    Section,
+    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
+
+TEAM_FIELDS = [
+    dp.Field(key="city", label=_("City")),
+    dp.Field(key="founded_date", label=_("Founded Date")),
+    dp.Field(key="coach", label=_("Coach"), tooltip=dp.Tooltip(key="coach_tooltip")),
+    dp.Field(key="home_stadium", label=_("Home Stadium")),
+]
+
+
+class TeamDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(
+            fields=TEAM_FIELDS,
+            tree=True,
+            tree_group_field="computed_str",
+            tree_group_label=_("Name"),
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_depth=1,
+                    lookup="current_players__id",
+                    filter_key="current_team",
+                    list_endpoint=reverse("example_app:treeviewplayer-list", args=[], request=self.request),
+                    reorder_endpoint=reverse("example_app:treeviewplayer-list", args=[], request=self.request)
+                    + "{{id}}/reorder/",
+                    reparent_endpoint=reverse("example_app:treeviewplayer-list", args=[], request=self.request)
+                    + "{{id}}/reparent/",
+                    parent_field="id",
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        players_section = Section(
+            key="players_section",
+            title=_("Players"),
+            display=Display(
+                pages=[
+                    Page(
+                        title=_("Players"),
+                        layouts={
+                            default(): Layout(
+                                grid_template_areas=[["players_inline"]],
+                                grid_template_columns=[
+                                    "minmax(min-content, 1fr)",
+                                ],
+                                grid_auto_rows=Style.MIN_CONTENT,
+                                inlines=[Inline(key="players_inline", endpoint="players")],
+                            )
+                        },
+                    ),
+                ]
+            ),
+        )
+        matches_section = Section(
+            key="matches_section",
+            collapsible=False,
+            title=_("Recent Matches"),
+            display=Display(
+                pages=[
+                    Page(
+                        title=_("Recent Matches"),
+                        layouts={
+                            default(): Layout(
+                                grid_template_areas=[["matches_inline"]],
+                                grid_template_columns=[
+                                    "minmax(min-content, 1fr)",
+                                ],
+                                grid_auto_rows=Style.MIN_CONTENT,
+                                inlines=[Inline(key="matches_inline", endpoint="recent_matches")],
+                            )
+                        },
+                    ),
+                ]
+            ),
+        )
+
+        is_create_display = "pk" not in self.view.kwargs
+
+        return Display(
+            pages=[
+                Page(
+                    title=_("Main Information"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=(
+                                [
+                                    ["name", "coach", "matches_section", "matches_section"],
+                                    ["home_stadium", ".", "matches_section", "matches_section"],
+                                    [".", ".", "matches_section", "matches_section"],
+                                    ["players_section", "players_section", "players_section", "players_section"],
+                                ]
+                                if not is_create_display
+                                else [
+                                    ["name", "name", "coach", "coach"],
+                                    ["home_stadium", "home_stadium", ".", "."],
+                                ]
+                            ),
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                            sections=[players_section, matches_section],
+                        ),
+                        lte(1000): Layout(
+                            grid_template_areas=(
+                                [
+                                    ["name", "coach"],
+                                    ["home_stadium", "."],
+                                    ["matches_section", "matches_section"],
+                                    ["players_section", "players_section"],
+                                ]
+                                if not is_create_display
+                                else [["name", "coach"], ["home_stadium", "."]]
+                            ),
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(3),
+                            sections=[players_section, matches_section],
+                        ),
+                        lte(450): Layout(
+                            grid_template_areas=[
+                                ["name"],
+                                ["coach"],
+                                ["home_stadium"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+                Page(
+                    title=_("Details"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[
+                                ["city", "founded_date"],
+                                ["phone_number", "email"],
+                                ["duration_since_last_win", "."],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(550): Layout(
+                            grid_template_areas=[
+                                ["city"],
+                                ["founded_date"],
+                                ["phone_number"],
+                                ["email"],
+                                ["duration_since_last_win"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ],
+        )
+
+
+class TeamStadiumDisplayConfig(TeamDisplayConfig):
+    def get_list_display(self) -> ListDisplay:
+        fields = TEAM_FIELDS.copy()
+        fields.insert(0, dp.Field(key="computed_str", label=_("Name")))
+        fields.pop(4)
+        return dp.ListDisplay(fields=fields)
+
+    def get_instance_display(self) -> Display:
+        if "pk" in self.view.kwargs:
+            return super().get_instance_display()
+
+        return Display(
+            pages=[
+                Page(
+                    title=_("Main Information"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[["name", "coach", "league"]],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(1000): Layout(
+                            grid_template_areas=[["name", "coach"], ["league", "."]],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(3),
+                        ),
+                        lte(450): Layout(
+                            grid_template_areas=[
+                                ["name"],
+                                ["coach"],
+                                ["league"],
+                            ],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+                Page(
+                    title=_("Details"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[["city", "founded_date"]],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                            column_gap=Style.rem(5),
+                        ),
+                        lte(550): Layout(
+                            grid_template_areas=[["city"], ["founded_date"]],
+                            grid_auto_columns="minmax(min-content, 1fr)",
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ],
+        )

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

@@ -0,0 +1,30 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.list_display import ListDisplay
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+TEAMRESULTS_FIELDS = [
+    dp.Field(key="league", label=_("League")),
+    dp.Field(key="team", label=_("Team")),
+    dp.Field(key="games_played", label=_("Games")),
+    dp.Field(key="wins", label=_("Wins")),
+    dp.Field(key="draws", label=_("Draws")),
+    dp.Field(key="losses", label=_("Losses")),
+    dp.Field(key="match_points_for", label=_("Match Points For")),
+    dp.Field(key="match_points_against", label=_("Match Points Against")),
+    dp.Field(key="match_point_difference", label=_("Match Point Difference")),
+    dp.Field(key="points", label=_("Points")),
+    dp.Field(key="form", label=_("Form")),
+]
+
+
+class TeamResultsDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return dp.ListDisplay(fields=TEAMRESULTS_FIELDS)
+
+
+class TeamResultsLeagueDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        fields = TEAMRESULTS_FIELDS.copy()
+        fields.pop(0)
+        return dp.ListDisplay(fields=fields)

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

@@ -0,0 +1,12 @@
+from .endpoints import (
+    PlayerTeamEndpointConfig,
+    MatchStadiumEndpointConfig,
+    EventMatchEndpointConfig,
+    TeamStadiumEndpointConfig,
+    EventTypeSportEndpointConfig,
+    EventEndpointConfig,
+    MatchLeagueEndpointConfig,
+    LeagueSportEndpointConfig,
+    TeamResultsEndpointConfig,
+    LeagueStatisticsEndpointConfig,
+)

wbcore/contrib/example_app/viewsets/endpoints/endpoints.py

@@ -0,0 +1,79 @@
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class PlayerTeamEndpointConfig(EndpointViewConfig):
+    def get_create_endpoint(self, **kwargs) -> str:
+        endpoint: str = super().get_create_endpoint(**kwargs)
+        if team_id := self.view.kwargs.get("team_id"):
+            endpoint += f"?team={team_id}"
+        return endpoint
+
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:player-team-list", args=[self.view.kwargs["team_id"]], request=self.request)
+
+
+class MatchStadiumEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:match-stadium-list", args=[self.view.kwargs["stadium_id"]], request=self.request)
+
+
+class MatchLeagueEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:match-league-list", args=[self.view.kwargs["league_id"]], request=self.request)
+
+
+class TeamStadiumEndpointConfig(EndpointViewConfig):
+    def get_create_endpoint(self, **kwargs) -> str:
+        endpoint: str = super().get_create_endpoint(**kwargs)
+        if stadium_id := self.view.kwargs.get("stadium_id"):
+            endpoint += f"?stadium={stadium_id}"
+        return endpoint
+
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:team-stadium-list", args=[self.view.kwargs["stadium_id"]], request=self.request)
+
+
+class LeagueSportEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:league-sport-list", args=[self.view.kwargs["sport_id"]], request=self.request)
+
+
+class EventTypeSportEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:eventtype-sport-list", args=[self.view.kwargs["sport_id"]], request=self.request)
+
+
+class EventEndpointConfig(EndpointViewConfig):
+    def get_delete_endpoint(self, **kwargs) -> None:
+        return None
+
+
+class LeagueStatisticsEndpointConfig(EndpointViewConfig):
+    def get_delete_endpoint(self, **kwargs) -> None:
+        return None
+
+    def get_create_endpoint(self, **kwargs) -> None:
+        return None
+
+    def get_instance_endpoint(self, **kwargs) -> None:
+        return None
+
+
+class EventMatchEndpointConfig(EventEndpointConfig):
+    def get_endpoint(self, **kwargs) -> str:
+        return reverse("example_app:event-match-list", args=[self.view.kwargs["match_id"]], request=self.request)
+
+    def get_create_endpoint(self, **kwargs) -> None:
+        return None
+
+
+class TeamResultsEndpointConfig(EndpointViewConfig):
+    def get_delete_endpoint(self, **kwargs) -> None:
+        return None
+
+    def get_instance_endpoint(self, **kwargs) -> None:
+        return None
+
+    def get_create_endpoint(self, **kwargs) -> None:
+        return None

wbcore/contrib/example_app/viewsets/event.py

@@ -0,0 +1,287 @@
+import pandas as pd
+import plotly.graph_objects as go
+import tablib
+from django.db.models import (
+    Case,
+    Count,
+    Exists,
+    F,
+    IntegerField,
+    OuterRef,
+    Q,
+    QuerySet,
+    Subquery,
+    When,
+)
+from django.shortcuts import get_object_or_404
+from django.utils.translation import gettext as _
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.example_app.filters import (
+    EventFilter,
+    EventMatchFilter,
+    EventTypeFilter,
+    EventTypeSportFilter,
+    PlayerStatisticsChartFilter,
+)
+from wbcore.contrib.example_app.models import (
+    Event,
+    EventType,
+    Match,
+    Player,
+    SportPerson,
+)
+from wbcore.contrib.example_app.serializers import (
+    EventModelSerializer,
+    EventRepresentationSerializer,
+    EventTypeModelSerializer,
+    EventTypeRepresentationSerializer,
+    LeaguePlayerStatisticsModelSerializer,
+    LeagueTeamStatisticsModelSerializer,
+)
+from wbcore.contrib.example_app.viewsets.displays import (
+    EventDisplayConfig,
+    EventMatchDisplayConfig,
+    EventTypeDisplayConfig,
+    EventTypeSportDisplayConfig,
+    LeaguePlayerStatisticsDisplayConfig,
+    LeagueTeamStatisticsDisplayConfig,
+)
+from wbcore.contrib.example_app.viewsets.endpoints import (
+    EventEndpointConfig,
+    EventMatchEndpointConfig,
+    EventTypeSportEndpointConfig,
+    LeagueStatisticsEndpointConfig,
+)
+from wbcore.contrib.example_app.viewsets.titles import (
+    EventTitleConfig,
+    EventTypeSportTitleConfig,
+    EventTypeTitleConfig,
+    PlayerStatisticsChartTitleConfig,
+)
+
+
+class EventModelViewSet(viewsets.ModelViewSet):
+    display_config_class = EventDisplayConfig
+    queryset = Event.objects.all()
+    search_fields = ("person__computed_str", "event_type__name")
+    serializer_class = EventModelSerializer
+    title_config_class = EventTitleConfig
+    ordering_fields = ("match__home", "minute", "person__computed_str", "event_type__name")
+    ordering = ("match__id", "minute", "person__computed_str", "event_type__name")
+    filterset_class = EventFilter
+    endpoint_config_class = EventEndpointConfig
+
+    @action(detail=False, methods=["PATCH"])
+    def matchevent(self, request, pk=None):
+        person_id = request.POST.get("person")
+        minute = request.POST.get("minute")
+        event_type_id = request.GET.get("event_type")
+        match_id = request.GET.get("match")
+        data = {"person": person_id, "minute": minute, "event_type": event_type_id, "match": match_id}
+        serializer = self.serializer_class(data=data, context={"request": request})
+        if serializer.is_valid():
+            person = get_object_or_404(SportPerson, pk=person_id)
+            event_type = get_object_or_404(EventType, pk=event_type_id)
+            match = get_object_or_404(Match, pk=match_id)
+            event = Event(person=person, minute=minute, event_type=event_type, match=match)
+            event.save()
+            return Response("Event Created", status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def get_queryset(self) -> QuerySet[Event]:
+        return super().get_queryset().select_related("person", "event_type", "match")
+
+
+class PlayerStatisticsChartModelViewSet(viewsets.ChartViewSet):
+    EXPORT_ALLOWED = True
+    queryset = Event.objects.all()
+    title_config_class = PlayerStatisticsChartTitleConfig
+    filterset_class = PlayerStatisticsChartFilter
+
+    def get_queryset(self):
+        return super().get_queryset().filter(person=self.kwargs["player_id"])
+
+    def _get_data_for_export(self, queryset, **kwargs) -> tablib.Dataset:
+        dataset = tablib.Dataset(headers=["League", "Event"])
+        for event in queryset.select_related("event_type", "match", "match__league"):
+            dataset.append([event.match.league.name, event.event_type.name])
+        return dataset
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        if queryset.exists():
+            df = pd.DataFrame(queryset.values("match__league__name", "event_type__name"))
+            df.fillna("None", inplace=True)
+            pivot_df = df.pivot_table(
+                index="match__league__name",
+                columns="event_type__name",
+                aggfunc="size",
+                fill_value=0,
+            )
+
+            for event_type in pivot_df.columns:
+                fig.add_trace(
+                    go.Histogram(
+                        histfunc="sum",
+                        y=pivot_df[event_type],
+                        x=pivot_df.index,
+                        name=f"{event_type}s",
+                    )
+                )
+
+            fig.update_layout(
+                xaxis=dict(title=_("League")),
+                yaxis=dict(title=_("Amount"), type="linear"),
+                autosize=True,
+                bargap=0.8,
+                bargroupgap=0.7,
+            )
+
+        return fig
+
+
+class LeaguePlayerStatisticsModelViewSet(viewsets.ModelViewSet):
+    endpoint_config_class = LeagueStatisticsEndpointConfig
+    serializer_class = LeaguePlayerStatisticsModelSerializer
+    display_config_class = LeaguePlayerStatisticsDisplayConfig
+    search_fields = ("person_name",)
+    ordering_fields = ("person_name", "count")
+    ordering = ("-count", "person_name", "person_id")
+
+    def get_queryset(self) -> QuerySet[Event]:
+        return (
+            Event.objects.filter(
+                match__league=self.kwargs["league_id"],
+                event_type=self.kwargs["event_type_id"],
+            )
+            .values("person")
+            .annotate(
+                count=Count("person"),
+                person_name=F("person__computed_str"),
+                person_id=F("person_id"),
+                id=F("person_id"),
+            )
+        )
+
+
+class LeagueTeamStatisticsModelViewSet(viewsets.ModelViewSet):
+    endpoint_config_class = LeagueStatisticsEndpointConfig
+    serializer_class = LeagueTeamStatisticsModelSerializer
+    display_config_class = LeagueTeamStatisticsDisplayConfig
+    search_fields = ("team_name",)
+    ordering_fields = ("team_name", "count")
+    ordering = ("-count", "team_name", "team_id")
+
+    def get_queryset(self) -> QuerySet[Event]:
+        return (
+            Event.objects.filter(
+                Q(match__league=self.kwargs["league_id"])
+                & Q(event_type=self.kwargs["event_type_id"])
+                & Q(
+                    Q(person__coached_team__isnull=False)
+                    | Q(person__in=Player.objects.filter(current_team__isnull=False).values("id"))
+                )
+            )
+            .values("person")
+            .annotate(
+                is_player=Exists(Player.objects.filter(id=OuterRef("person_id"), current_team__isnull=False)),
+                is_coach=Q(person__coached_team__isnull=False),
+                team_id=Case(
+                    When(
+                        is_player=True,
+                        then=Subquery(Player.objects.filter(id=OuterRef("person_id")).values("current_team__id")[:1]),
+                    ),
+                    When(
+                        is_coach=True,
+                        then=F("person__coached_team__id"),
+                    ),
+                    output_field=IntegerField(),
+                ),
+            )
+            .values("team_id")
+            .annotate(
+                count=Count("person"),
+                id=F("team_id"),
+                team_name=Case(
+                    When(
+                        is_player=True,
+                        then=Subquery(
+                            Player.objects.filter(id=OuterRef("person_id")).values("current_team__name")[:1]
+                        ),
+                    ),
+                    When(
+                        is_coach=True,
+                        then=F("person__coached_team__name"),
+                    ),
+                ),
+            )
+        )
+
+
+class EventMatchModelViewSet(EventModelViewSet):
+    display_config_class = EventMatchDisplayConfig
+    ordering_fields = ("minute", "person__computed_str", "event_type__name")
+    ordering = ("minute", "person__computed_str", "event_type__name")
+    filterset_class = EventMatchFilter
+    endpoint_config_class = EventMatchEndpointConfig
+
+    def get_queryset(self) -> QuerySet[Event]:
+        queryset = super().get_queryset()
+        if match_id := self.kwargs.get("match_id"):
+            queryset = queryset.filter(match=match_id)
+        return queryset
+
+
+class EventRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Event.objects.all()
+    serializer_class = EventRepresentationSerializer
+    search_fields = ("event_type__name", "minute", "person__computed_str")
+
+
+class EventTypeModelViewSet(viewsets.ModelViewSet):
+    display_config_class = EventTypeDisplayConfig
+    queryset = EventType.objects.all()
+    search_fields = ("name", "sport")
+    serializer_class = EventTypeModelSerializer
+    title_config_class = EventTypeTitleConfig
+    ordering_fields = (
+        "name",
+        "points",
+        "sport__name",
+        "icon",
+        "color",
+    )
+    ordering = ("sport", "name")
+    filterset_class = EventTypeFilter
+
+    def get_queryset(self) -> QuerySet[EventType]:
+        return super().get_queryset().select_related("sport")
+
+
+class EventTypeSportModelViewSet(EventTypeModelViewSet):
+    display_config_class = EventTypeSportDisplayConfig
+    ordering_fields = (
+        "name",
+        "points",
+        "icon",
+        "color",
+    )
+    ordering = ("name",)
+    filterset_class = EventTypeSportFilter
+    endpoint_config_class = EventTypeSportEndpointConfig
+    title_config_class = EventTypeSportTitleConfig
+
+    def get_queryset(self) -> QuerySet[EventType]:
+        queryset = super().get_queryset()
+        if sport_id := self.kwargs.get("sport_id"):
+            queryset = queryset.filter(sport=sport_id)
+        return queryset
+
+
+class EventTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = EventType.objects.all()
+    serializer_class = EventTypeRepresentationSerializer
+    search_fields = ("name",)