wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/documents/viewsets/previews/documents.py

@@ -0,0 +1,10 @@
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.preview import PreviewViewConfig
+
+
+class DocumentPreviewConfig(PreviewViewConfig):
+    def get_display(self) -> Display:
+        return create_simple_display([["name", "document_type", "description"]])

wbcore/contrib/documents/viewsets/shareable_links.py

@@ -0,0 +1,109 @@
+import json
+from datetime import datetime
+from uuid import UUID
+
+from django.db.models import Q
+from django.http.request import HttpRequest
+from django.http.response import FileResponse, HttpResponse
+from django.shortcuts import get_object_or_404
+from django.views.generic import View
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.documents.filters import (
+    ShareableLinkAccessFilter,
+    ShareableLinkFilter,
+)
+from wbcore.contrib.documents.models import ShareableLink, ShareableLinkAccess
+from wbcore.contrib.documents.serializers import (
+    ShareableLinkAccessModelSerializer,
+    ShareableLinkAccessRepresentationSerializer,
+    ShareableLinkModelSerializer,
+    ShareableLinkRepresentationSerializer,
+)
+from wbcore.contrib.documents.viewsets.buttons import ShareableLinkModelButtonConfig
+from wbcore.contrib.documents.viewsets.display import (
+    ShareableLinkAccessModelDisplay,
+    ShareableLinkModelDisplay,
+)
+from wbcore.contrib.documents.viewsets.endpoints import (
+    ShareableLinkAccessEndpointConfig,
+    ShareableLinkEndpointConfig,
+)
+from wbcore.contrib.documents.viewsets.titles import ShareableLinkModelTitleConfig
+
+
+class DownloadShareableLinkView(View):
+    def get(self, request: HttpRequest, uuid: UUID) -> HttpResponse:
+        link = get_object_or_404(ShareableLink, uuid=uuid)
+        if link.is_valid() and link.document.file.name:
+            json_meta = json.loads(json.dumps(request.META, default=str))
+            link.access(metadata=json_meta)
+            if (content_type := link.document.content_type) and (filename := link.document.filename):
+                with link.document.file.open("r") as f:
+                    return FileResponse(f, as_attachment=True, filename=filename, content_type=content_type)
+        return HttpResponse("Link invalid", status=status.HTTP_204_NO_CONTENT)
+
+
+class ShareableLinkModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/shareablelink.md"
+    search_fields = ("uuid",)
+    ordering = ["valid_until"]
+    ordering_fields = (
+        "valid_until",
+        "one_time_link",
+    )
+    queryset = ShareableLink.objects.all()
+    serializer_class = ShareableLinkModelSerializer
+    title_config_class = ShareableLinkModelTitleConfig
+    filterset_class = ShareableLinkFilter
+    endpoint_config_class = ShareableLinkEndpointConfig
+    button_config_class = ShareableLinkModelButtonConfig
+    display_config_class = ShareableLinkModelDisplay
+
+    @action(detail=True, methods=["PATCH"])
+    def invalidate(self, request, pk=None):
+        shareable_link = ShareableLink.objects.get(pk=pk)
+        if shareable_link.manual_invalid:
+            return Response({}, status=status.HTTP_400_BAD_REQUEST)
+        shareable_link.manual_invalid = True
+        shareable_link.save()
+        return Response({}, status=status.HTTP_200_OK)
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                valid=Q(manual_invalid=False) & (Q(valid_until__isnull=True) | Q(valid_until__gte=datetime.now()))
+            )
+        )
+
+
+class ShareableLinkRepresentationViewSet(viewsets.RepresentationViewSet):
+    serializer_class = ShareableLinkRepresentationSerializer
+    queryset = ShareableLink.objects.all()
+    search_fields = ("document",)
+
+
+class ShareableLinkAccessModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/shareablelinkaccess.md"
+    ordering = ["accessed"]
+    ordering_fields = (
+        "ipaddress",
+        "metadata",
+        "accessed",
+    )
+    queryset = ShareableLinkAccess.objects.all()
+    serializer_class = ShareableLinkAccessModelSerializer
+    endpoint_config_class = ShareableLinkAccessEndpointConfig
+    filterset_class = ShareableLinkAccessFilter
+
+    display_config_class = ShareableLinkAccessModelDisplay
+
+
+class ShareableLinkAccessRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = ShareableLinkAccess.objects.all()
+    serializer_class = ShareableLinkAccessRepresentationSerializer
+    search_fields = ("ipaddress",)

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

@@ -0,0 +1,3 @@
+from .document_types import DocumentTypeModelTitleConfig
+from .documents import DocumentModelTitleConfig
+from .shareable_links import ShareableLinkModelTitleConfig

wbcore/contrib/documents/viewsets/titles/document_types.py

@@ -0,0 +1,13 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class DocumentTypeModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("Document Types")
+
+    def get_instance_title(self):
+        return _("Document Type: {{name}}")
+
+    def get_create_title(self):
+        return _("New Document Type")

wbcore/contrib/documents/viewsets/titles/documents.py

@@ -0,0 +1,26 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+def get_object_by_content(content_type, content_id):
+    return str(ContentType.objects.get_for_id(content_type).model_class().objects.get(id=content_id))
+
+
+class DocumentModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        if (content_id := self.view.kwargs.get("content_id", None)) and (
+            content_type := self.view.kwargs.get("content_type", None)
+        ):
+            return _("Documents for {object}").format(object=get_object_by_content(content_type, content_id))
+        return _("Documents")
+
+    def get_instance_title(self):
+        return _("Document: {{name}}")
+
+    def get_create_title(self):
+        if (content_id := self.view.kwargs.get("content_id", None)) and (
+            content_type := self.view.kwargs.get("content_type", None)
+        ):
+            return _("New Document for {object}").format(object=get_object_by_content(content_type, content_id))
+        return _("New Document")

wbcore/contrib/documents/viewsets/titles/shareable_links.py

@@ -0,0 +1,13 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class ShareableLinkModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("Shareable Links")
+
+    def get_instance_title(self):
+        return _("Shareable Link")
+
+    def get_create_title(self):
+        return _("New Shareable Link")

wbcore/contrib/dynamic_preferences/types.py

@@ -0,0 +1,19 @@
+from dynamic_preferences.types import ModelChoicePreference
+
+
+class CallableDefaultModelChoicePreference(ModelChoicePreference):
+    """
+    Propose a ModelChoicePreference class where default is allowed to be a callable property. This avoids unnecessary db calls at start
+
+    This type expects a mandatory model attribute and a section of type dynamic_preferences.Section.
+    """
+
+    def __init__(self, registry=None):
+        self.registry = registry
+        self.queryset = self.model.objects.all()
+        self.serializer = self.serializer_class(self.model)
+        self._setup_signals()
+
+    @property
+    def default(self):
+        raise NotImplementedError("Default property needs to be defined for this preference type")

wbcore/contrib/example_app/admin.py

@@ -0,0 +1,117 @@
+from django.contrib import admin
+from wbcore.contrib.example_app.models import (
+    Event,
+    EventType,
+    League,
+    Match,
+    Player,
+    Role,
+    Sport,
+    SportPerson,
+    Stadium,
+    Team,
+    TeamResults,
+)
+
+
+@admin.register(SportPerson)
+class SportPersonAdmin(admin.ModelAdmin):
+    search_fields = ("first_name", "last_name")
+    list_display = ("id", "first_name", "last_name")
+    raw_id_fields = ["roles"]
+
+
+@admin.register(Sport)
+class SportAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "rules", "match_duration")
+
+
+@admin.register(League)
+class LeagueAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = (
+        "id",
+        "name",
+        "sport",
+        "points_per_win",
+        "points_per_draw",
+        "points_per_loss",
+        "country",
+        "established_date",
+        "commissioner",
+        "website",
+    )
+
+
+@admin.register(Stadium)
+class StadiumAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "city", "total_capacity", "seating_capacity", "standing_capacity")
+
+
+@admin.register(Team)
+class TeamAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+    list_display = ("id", "name", "city", "founded_date", "coach", "home_stadium")
+    raw_id_fields = ["opponents"]
+
+
+@admin.register(Player)
+class PlayerAdmin(SportPersonAdmin):
+    list_display = SportPersonAdmin.list_display + ("position", "current_team", "transfer_value")
+    raw_id_fields = ["former_teams"]
+
+
+@admin.register(Role)
+class RoleAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+@admin.register(Match)
+class MatchAdmin(admin.ModelAdmin):
+    search_fields = ("home", "away")
+    list_display = (
+        "id",
+        "home",
+        "away",
+        "sport",
+        "league",
+        "date_time",
+        "stadium",
+        "status",
+        "score_home",
+        "score_away",
+        "referee",
+    )
+
+
+@admin.register(Event)
+class EventAdmin(admin.ModelAdmin):
+    search_fields = ("person", "event_type", "match")
+    list_display = ("id", "person", "minute", "event_type", "match")
+
+
+@admin.register(EventType)
+class EventTypeAdmin(admin.ModelAdmin):
+    search_fields = ("name", "sport")
+    list_display = ("id", "name", "sport", "points", "icon")
+
+
+@admin.register(TeamResults)
+class TeamResultsAdmin(admin.ModelAdmin):
+    search_fields = ("team", "league")
+    list_display = (
+        "id",
+        "team",
+        "league",
+        "points",
+        "match_point_difference",
+        "match_points_for",
+        "match_points_against",
+        "wins",
+        "draws",
+        "losses",
+        "form",
+    )

wbcore/contrib/example_app/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ExampleAppConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "wbcore.contrib.example_app"

wbcore/contrib/example_app/factories/__init__.py

@@ -0,0 +1,8 @@
+from .event import EventFactory, EventTypeFactory
+from .league import LeagueFactory
+from .match import MatchFactory
+from .person import SportPersonFactory, PlayerFactory
+from .role import RoleFactory
+from .sport import SportFactory
+from .stadium import StadiumFactory
+from .team import TeamFactory, TeamResultsFactory

wbcore/contrib/example_app/factories/event.py

@@ -0,0 +1,26 @@
+import random
+
+import factory
+from wbcore.contrib.example_app.models import Event, EventType
+from wbcore.contrib.icons.icons import WBIcon
+
+
+class EventTypeFactory(factory.django.DjangoModelFactory):
+    name = factory.Sequence(lambda n: "Event %d" % n)
+    sport = factory.SubFactory("wbcore.contrib.example_app.factories.SportFactory")
+    points = factory.Faker("pyint", min_value=0, max_value=3)
+    icon = factory.LazyAttribute(lambda x: WBIcon[random.choice(WBIcon.names)].icon)
+    color = factory.Faker("color")
+
+    class Meta:
+        model = EventType
+
+
+class EventFactory(factory.django.DjangoModelFactory):
+    person = factory.SubFactory("wbcore.contrib.example_app.factories.SportPersonFactory")
+    match = factory.SubFactory("wbcore.contrib.example_app.factories.MatchFactory")
+    minute = factory.Faker("random_int", min=1, max=factory.SelfAttribute("..match.league.sport.match_duration"))
+    event_type = factory.SubFactory(EventTypeFactory, sport=factory.SelfAttribute("..match.sport"))
+
+    class Meta:
+        model = Event

wbcore/contrib/example_app/factories/league.py

@@ -0,0 +1,15 @@
+import factory
+from wbcore.contrib.example_app.models import League
+
+
+class LeagueFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = League
+
+    # country = factory.SubFactory("wbcore.contrib.geography.factories.CountryFactory")
+    name = factory.Sequence(lambda n: "League %d" % n)
+    points_per_win = factory.Faker("pyint", min_value=2, max_value=3)
+    sport = factory.SubFactory("wbcore.contrib.example_app.factories.SportFactory")
+    commissioner = factory.SubFactory("wbcore.contrib.example_app.factories.SportPersonFactory")
+    established_date = factory.Faker("date_object")
+    website = factory.Faker("url")

wbcore/contrib/example_app/factories/match.py

@@ -0,0 +1,25 @@
+import factory
+import pytz
+from faker import Faker
+from wbcore.contrib.agenda.factories import CalendarItemFactory
+from wbcore.contrib.example_app.models import Match
+
+fake = Faker()
+
+
+class MatchFactory(CalendarItemFactory):
+    class Meta:
+        model = Match
+
+    home = factory.SubFactory("wbcore.contrib.example_app.factories.TeamFactory")
+    away = factory.SubFactory("wbcore.contrib.example_app.factories.TeamFactory")
+
+    date_time = factory.LazyAttribute(lambda _: fake.date_time(tzinfo=pytz.utc))
+    stadium = factory.SubFactory("wbcore.contrib.example_app.factories.StadiumFactory")
+    status = factory.Faker("random_element", elements=[x[0] for x in Match.MatchStatus])
+    score_home = factory.Faker("pyint", min_value=0, max_value=1000)
+    score_away = factory.Faker("pyint", min_value=0, max_value=1000)
+    referee = factory.SubFactory("wbcore.contrib.example_app.factories.SportPersonFactory")
+    league = factory.SubFactory("wbcore.contrib.example_app.factories.LeagueFactory")
+    sport = factory.SelfAttribute(".league.sport")
+    task_id = factory.Faker("text", max_nb_chars=50)

wbcore/contrib/example_app/factories/person.py

@@ -0,0 +1,32 @@
+import factory
+from wbcore.contrib.example_app.models import Player, SportPerson
+
+
+class SportPersonFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = SportPerson
+
+    profile = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    profile_image = factory.django.ImageField(filename="image_profile.jpeg")
+    first_name = factory.SelfAttribute("profile.first_name")
+    last_name = factory.SelfAttribute("profile.last_name")
+
+    @factory.post_generation
+    def roles(self, create, extracted, **kwargs):
+        if extracted:
+            for role in extracted:
+                self.roles.add(role)
+
+
+class PlayerFactory(SportPersonFactory):
+    position = factory.Faker("text", max_nb_chars=15)
+    current_team = factory.SubFactory("wbcore.contrib.example_app.factories.TeamFactory")
+
+    @factory.post_generation
+    def former_teams(self, create, extracted, **kwargs):
+        if extracted:
+            for team in extracted:
+                self.former_teams.add(team)
+
+    class Meta:
+        model = Player

wbcore/contrib/example_app/factories/role.py

@@ -0,0 +1,9 @@
+import factory
+from wbcore.contrib.example_app.models import Role
+
+
+class RoleFactory(factory.django.DjangoModelFactory):
+    title = factory.Sequence(lambda n: "Role %d" % n)
+
+    class Meta:
+        model = Role

wbcore/contrib/example_app/factories/sport.py

@@ -0,0 +1,12 @@
+import factory
+from wbcore.contrib.example_app.models import Sport
+
+
+class SportFactory(factory.django.DjangoModelFactory):
+    name = factory.Sequence(lambda n: "Sport %d" % n)
+
+    rules = factory.Faker("text", max_nb_chars=100)
+    match_duration = factory.Faker("pyint", min_value=1, max_value=250)
+
+    class Meta:
+        model = Sport

wbcore/contrib/example_app/factories/stadium.py

@@ -0,0 +1,12 @@
+import factory
+from wbcore.contrib.example_app.models import Stadium
+
+
+class StadiumFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("text", max_nb_chars=16)
+    standing_capacity = factory.Faker("pyint", min_value=100, max_value=100000)
+    seating_capacity = factory.Faker("pyint", min_value=100, max_value=100000)
+    # city = factory.SubFactory("wbcore.contrib.geography.factories.CityFactory")
+
+    class Meta:
+        model = Stadium

wbcore/contrib/example_app/factories/team.py

@@ -0,0 +1,35 @@
+import factory
+from wbcore.contrib.directory.factories import CompanyFactory
+from wbcore.contrib.example_app.models import Team, TeamResults
+
+
+class TeamFactory(CompanyFactory):
+    coach = factory.SubFactory("wbcore.contrib.example_app.factories.SportPersonFactory")
+    home_stadium = factory.SubFactory("wbcore.contrib.example_app.factories.StadiumFactory")
+    founded_date = factory.Faker("date_object")
+    # city = factory.SubFactory("wbcore.contrib.geography.factories.CityFactory")
+
+    @factory.post_generation
+    def opponents(self, create, extracted, **kwargs):
+        if extracted:
+            for team in extracted:
+                self.opponents.add(team)
+
+    class Meta:
+        model = Team
+
+
+class TeamResultsFactory(factory.django.DjangoModelFactory):
+    team = factory.SubFactory(TeamFactory)
+    league = factory.SubFactory("wbcore.contrib.example_app.factories.LeagueFactory")
+    points = factory.Faker("pyint")
+    match_points_for = factory.Faker("pyint")
+    match_points_against = factory.Faker("pyint")
+    match_point_difference = factory.Faker("pyint", min_value=-500)
+    wins = factory.Faker("pyint")
+    draws = factory.Faker("pyint")
+    losses = factory.Faker("pyint")
+    form = factory.Faker("text", max_nb_chars=5)
+
+    class Meta:
+        model = TeamResults

wbcore/contrib/example_app/filters/__init__.py

@@ -0,0 +1,9 @@
+from .team import TeamFilter, TeamStadiumFilter
+from .person import PlayerTeamFilter, PlayerFilter, SportPersonFilter, SportPersonRepresentationFilter
+from .role import RoleFilter
+from .stadium import StadiumFilter
+from .league import LeagueFilter, LeagueSportFilter
+from .sport import SportFilter
+from .match import MatchFilter, MatchLeagueFilter, MatchStadiumFilter
+from .event import EventFilter, EventTypeFilter, EventTypeSportFilter, EventMatchFilter, PlayerStatisticsChartFilter
+from .teamresult import TeamResultsFilter, TeamResultsLeagueFilter

wbcore/contrib/example_app/filters/event.py

@@ -0,0 +1,80 @@
+from django.db.models import QuerySet
+from django.utils.translation import gettext_lazy as _
+from psycopg.types.range import DateRange, TimestamptzRange
+from wbcore import filters
+from wbcore.contrib.example_app.models import (
+    Event,
+    EventType,
+    Match,
+    Sport,
+    SportPerson,
+)
+from wbcore.filters.defaults import current_year_date_range
+
+
+class EventMatchFilter(filters.FilterSet):
+    person = filters.ModelMultipleChoiceFilter(
+        label=_("Persons"),
+        queryset=SportPerson.objects.all(),
+        endpoint=SportPerson.get_representation_endpoint(),
+        value_key=SportPerson.get_representation_value_key(),
+        label_key=SportPerson.get_representation_label_key(),
+    )
+    minute__gte = filters.NumberFilter(label=_("Minute"), lookup_expr="gte", field_name="minute")
+    minute__lte = filters.NumberFilter(label=_("Minute"), lookup_expr="lte", field_name="minute")
+    event_type = filters.ModelMultipleChoiceFilter(
+        label=_("Event Types"),
+        queryset=SportPerson.objects.all(),
+        endpoint=SportPerson.get_representation_endpoint(),
+        value_key=SportPerson.get_representation_value_key(),
+        label_key=SportPerson.get_representation_label_key(),
+    )
+
+    class Meta:
+        model = Event
+        fields = {}
+
+
+class EventFilter(EventMatchFilter):
+    match = filters.ModelChoiceFilter(
+        label=_("Match"),
+        queryset=Match.objects.all(),
+        endpoint=Match.get_representation_endpoint(),
+        value_key=Match.get_representation_value_key(),
+        label_key=Match.get_representation_label_key(),
+    )
+
+
+class EventTypeSportFilter(filters.FilterSet):
+    points__gte = filters.NumberFilter(label=_("Points"), lookup_expr="gte", field_name="points")
+    points__lte = filters.NumberFilter(label=_("Points"), lookup_expr="lte", field_name="points")
+
+    class Meta:
+        model = EventType
+        fields = {
+            "name": ["exact", "icontains"],
+            "icon": ["exact", "icontains"],
+        }
+
+
+class EventTypeFilter(EventTypeSportFilter):
+    sport = filters.ModelMultipleChoiceFilter(
+        label=_("Sports"),
+        queryset=Sport.objects.all(),
+        endpoint=Sport.get_representation_endpoint(),
+        value_key=Sport.get_representation_value_key(),
+        label_key=Sport.get_representation_label_key(),
+    )
+
+
+class PlayerStatisticsChartFilter(filters.FilterSet):
+    minute__gte = filters.NumberFilter(label=_("Minute"), lookup_expr="gte", field_name="minute")
+    minute__lte = filters.NumberFilter(label=_("Minute"), lookup_expr="lte", field_name="minute")
+    period = filters.DateRangeFilter(label=_("Period"), method="filter_by_period", default=current_year_date_range)
+
+    def filter_by_period(self, queryset: QuerySet[Event], name, value: DateRange) -> QuerySet[Event]:
+        return queryset.filter(match__date_time__contained_by=TimestamptzRange(value.lower, value.upper))
+
+    class Meta:
+        model = Event
+        fields = {}