wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/example_app/serializers/person_team.py

@@ -0,0 +1,281 @@
+from datetime import date
+from enum import Enum
+
+import phonenumbers
+from django.core.validators import validate_email
+from django.forms import ValidationError
+from django.utils import timezone
+from django.utils.translation import gettext as _
+from django.utils.translation import pgettext_lazy
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework.reverse import reverse
+from slugify import slugify
+
+from wbcore import serializers
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.contrib.example_app.models import Player, Role, SportPerson, Stadium, Team
+from wbcore.contrib.example_app.serializers import (
+    RoleRepresentationSerializer,
+    StadiumRepresentationSerializer,
+)
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+from wbcore.serializers.fields.number import DisplayMode
+
+
+class TeamErrorMessages(Enum):
+    team_exists = _("A team with this name already exists.")
+    wrong_founding_date = _("The founding date must be in the past.")
+
+
+class SportPersonModelSerializer(serializers.ModelSerializer):
+    profile = serializers.PrimaryKeyRelatedField(read_only=True)
+    _profile = PersonRepresentationSerializer(many=False, source="profile")
+    _roles = RoleRepresentationSerializer(source="roles", many=True)
+
+    def create(self, validated_data):
+        if not validated_data.get("profile", None):
+            person = Person.objects.create(
+                first_name=validated_data["first_name"], last_name=validated_data["last_name"]
+            )
+            validated_data["profile"] = person
+        return super().create(validated_data)
+
+    class Meta:
+        model = SportPerson
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "computed_str",
+            "roles",
+            "_roles",
+            "profile",
+            "_profile",
+            "profile_image",
+            "_additional_resources",
+        )
+
+
+class SportPersonTooltipSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = SportPerson
+        fields = ("id", "first_name", "last_name", "profile_image")
+
+
+class SportPersonRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:person-detail")
+
+    class Meta:
+        model = SportPerson
+        fields = ("id", "computed_str", "_detail")
+
+
+class TeamRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:team-detail")
+
+    class Meta:
+        model = Team
+        fields = ("id", "name", "_detail")
+
+
+class TeamModelSerializer(serializers.ModelSerializer):
+    name = serializers.CharField(placeholder=_("Enter team name here"))
+    _coach = SportPersonRepresentationSerializer(source="coach")
+    home_stadium = serializers.PrimaryKeyRelatedField(
+        queryset=Stadium.objects.all(), label=_("Home Stadium"), default=serializers.DefaultFromGET("stadium")
+    )
+    _home_stadium = StadiumRepresentationSerializer(source="home_stadium")
+    _city = GeographyRepresentationSerializer(filter_params={"level": 3}, source="city")
+    _opponents = TeamRepresentationSerializer(source="opponents", many=True)
+    _group_key = serializers.IntegerField(read_only=True)
+    phone_number = serializers.TelephoneField(label=pgettext_lazy("Phonenumber", "Number"), required=False)
+
+    def validate(self, data: dict) -> dict:
+        name: str | None = data.get("name", None)
+        founded_date: date | None = data.get("founded_date", None)
+        phone_number = data.get("phone_number", None)
+        email = data.get("email", None)
+
+        if name:
+            team = Team.objects.filter(slugify_name=slugify(name, separator=" "))
+            if obj := self.instance:
+                team = team.exclude(id=obj.id)
+            if team.exists():
+                raise ValidationError({"name": TeamErrorMessages.team_exists.value})
+        if founded_date and founded_date > timezone.now().date():
+            raise ValidationError({"founded_date": TeamErrorMessages.wrong_founding_date.value})
+        if email:
+            try:
+                validate_email(email)
+            except ValidationError as e:
+                raise ValidationError({"email": _("Invalid e-mail address")}) from e
+        if phone_number:
+            try:
+                if phone_number.startswith("00"):
+                    phone_number = phone_number.replace("00", "+", 1)
+                parser_number = phonenumbers.parse(
+                    phone_number, global_preferences_registry.manager()["directory__main_country_code"]
+                )
+                if parser_number:
+                    formatted_number = phonenumbers.format_number(parser_number, phonenumbers.PhoneNumberFormat.E164)
+                    data["phone_number"] = formatted_number
+            except Exception as e:
+                raise ValidationError({"phone_number": _("Invalid phone number format")}) from e
+
+        return super().validate(data)
+
+    @serializers.register_resource()
+    def website(self, instance: Team, request, user):
+        return {"website": instance.website}
+
+    @serializers.register_resource()
+    def coach(self, instance: Team, request, user):
+        if instance.coach:
+            return {
+                "coach": reverse(
+                    "example_app:person-detail",
+                    args=[instance.coach.id],
+                    request=self.context.get("request"),
+                )
+            }
+        return {}
+
+    @serializers.register_resource()
+    def coach_tooltip(self, instance: Team, request, user):
+        if instance.coach:
+            return {
+                "coach_tooltip": reverse(
+                    "example_app:persontooltip-detail",
+                    args=[instance.coach.id],
+                    request=self.context.get("request"),
+                )
+            }
+        return {}
+
+    @serializers.register_only_instance_resource()
+    def players_inline(self, instance: Team, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "players": reverse("example_app:player-team-list", args=[instance.pk], request=self.context["request"])
+        }
+
+    @serializers.register_only_instance_resource()
+    def matches_inline(self, instance: Team, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "recent_matches": reverse(
+                "example_app:match-team-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    class Meta:
+        model = Team
+        fields = (
+            "id",
+            "name",
+            "slugify_name",
+            "computed_str",
+            "city",
+            "_city",
+            "coach",
+            "_coach",
+            "home_stadium",
+            "_home_stadium",
+            "opponents",
+            "_opponents",
+            "founded_date",
+            "website",
+            "phone_number",
+            "email",
+            "duration_since_last_win",
+            "order",
+            "_group_key",
+            "_additional_resources",
+        )
+        read_only_fields = ("duration_since_last_win",)
+        optional_fields = ("current_players", "former_players", "home_matches", "away_matches")
+
+
+def get_player_role() -> list[Role]:
+    player_role, created = Role.objects.get_or_create(title="Player")
+    return [player_role]
+
+
+class PlayerModelSerializer(SportPersonModelSerializer):
+    roles = serializers.PrimaryKeyRelatedField(
+        queryset=Role.objects.all(), label=_("Roles"), default=get_player_role, many=True
+    )
+    _roles = RoleRepresentationSerializer(source="roles", many=True)
+    current_team = serializers.PrimaryKeyRelatedField(
+        queryset=Team.objects.all(),
+        label=_("Current Team"),
+        default=serializers.DefaultFromGET("team"),
+    )
+    transfer_value = serializers.DecimalField(
+        display_mode=DisplayMode.SHORTENED, precision=1, max_digits=10, decimal_places=2
+    )
+    game_activity = serializers.RangeSelectField(
+        color="rgb(220,20,60)", label=_("Activity Heat"), read_only=True, required=False
+    )
+    _current_team = TeamRepresentationSerializer(source="current_team")
+    _former_teams = TeamRepresentationSerializer(source="former_teams", many=True)
+    _overwrites = serializers.SerializerMethodField("overwrites")
+    player_strength = serializers.StarRatingField()
+
+    def overwrites(self, obj):
+        if obj:
+            transfer_value = obj.transfer_value if obj.transfer_value else 0
+            operator = "!=" if transfer_value < 99999 else "="
+            overwrite = {
+                "fields": [
+                    {
+                        "rule": {"key": "transfer_value", "operator": operator, "value": "number"},
+                        "overwrite": {"displayMode": "decimal", "precision": 0},
+                    }
+                ]
+            }
+            return overwrite
+
+    def validate_player_strength(self, value):
+        if value < 0 or value > 5:
+            raise ValidationError(_("Rating must be between 0 and 5."))
+        return value
+
+    class Meta:
+        model = Player
+        fields = (
+            "id",
+            "first_name",
+            "last_name",
+            "computed_str",
+            "roles",
+            "_roles",
+            "current_team",
+            "_current_team",
+            "is_active",
+            "is_injured",
+            "former_teams",
+            "_former_teams",
+            "position",
+            "player_strength",
+            "game_activity",
+            "transfer_value",
+            "_overwrites",
+        )
+
+
+class TreeViewPlayerModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Player
+        fields = ("id", "order", "computed_str", "current_team")
+
+
+class PlayerRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:player-detail")
+
+    class Meta:
+        model = Player
+        fields = ("id", "computed_str", "_detail")

wbcore/contrib/example_app/serializers/role.py

@@ -0,0 +1,16 @@
+from wbcore import serializers
+from wbcore.contrib.example_app.models import Role
+
+
+class RoleModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Role
+        fields = "__all__"
+
+
+class RoleRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:role-detail")
+
+    class Meta:
+        model = Role
+        fields = ("id", "title", "_detail")

wbcore/contrib/example_app/serializers/season.py

@@ -0,0 +1,54 @@
+from django.forms import ValidationError
+from django.utils import timezone
+
+from wbcore import serializers
+from wbcore.contrib.example_app.models import Season
+from wbcore.contrib.example_app.serializers import (
+    LeagueRepresentationSerializer,
+    PlayerRepresentationSerializer,
+    TeamRepresentationSerializer,
+)
+
+
+class SeasonModelSerializer(serializers.ModelSerializer):
+    _league = LeagueRepresentationSerializer(source="league", many=False)
+    _winner = TeamRepresentationSerializer(source="winner", many=False)
+    _top_scorer = PlayerRepresentationSerializer(source="top_scorer")
+
+    def validate(self, data):
+        date_range = data.get("date_range", None)
+        winner = data.get("winner", None)
+        top_scorer = data.get("top_scorer", None)
+
+        if date_range and date_range.upper > timezone.now().date():
+            if winner:
+                raise ValidationError({"winner": "You cannot choose a winner, when the season is not finished"})
+            if top_scorer:
+                raise ValidationError(
+                    {"top_scorer": "You cannot choose a top scorer, when the season is not finished"}
+                )
+
+        return super().validate(data)
+
+    class Meta:
+        model = Season
+        fields = [
+            "id",
+            "name",
+            "league",
+            "_league",
+            "date_range",
+            "file",
+            "winner",
+            "_winner",
+            "top_scorer",
+            "_top_scorer",
+        ]
+
+
+class SeasonRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:season-detail")
+
+    class Meta:
+        model = Season
+        fields = ("id", "name", "_detail")

wbcore/contrib/example_app/serializers/sport.py

@@ -0,0 +1,38 @@
+from rest_framework.reverse import reverse
+
+from wbcore import serializers
+from wbcore.contrib.example_app.models import Sport
+
+
+class SportModelSerializer(serializers.ModelSerializer):
+    @serializers.register_only_instance_resource()
+    def leagues_inline(self, instance: Sport, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "existing_leagues": reverse(
+                "example_app:league-sport-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    @serializers.register_only_instance_resource()
+    def event_types_inline(self, instance: Sport, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "associated_event_types": reverse(
+                "example_app:eventtype-sport-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    class Meta:
+        model = Sport
+        fields = "__all__"
+
+
+class SportRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:sport-detail")
+
+    class Meta:
+        model = Sport
+        fields = ("id", "name", "_detail")

wbcore/contrib/example_app/serializers/stadium.py

@@ -0,0 +1,59 @@
+from django.forms import ValidationError
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+
+from wbcore import serializers
+from wbcore.contrib.example_app.models import Stadium
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+
+
+class StadiumModelSerializer(serializers.ModelSerializer):
+    _city = GeographyRepresentationSerializer(filter_params={"level": 3}, source="city")
+    total_capacity = serializers.DecimalField(decimal_places=0, max_digits=10, read_only=True)
+    guest_rating = serializers.EmojiRatingField()
+
+    def validate_guest_rating(self, value):
+        if value < 0 or value > 4:
+            raise ValidationError(_("Guest rating must be between 0 and 4."))
+        return value
+
+    @serializers.register_only_instance_resource()
+    def teams_inline(self, instance: Stadium, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "teams_playing": reverse(
+                "example_app:team-stadium-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    @serializers.register_only_instance_resource()
+    def matches_inline(self, instance: Stadium, request, user, view, **kwargs) -> dict[str, str]:
+        if not self.context.get("request"):
+            return {}
+        return {
+            "recent_matches": reverse(
+                "example_app:match-stadium-list", args=[instance.pk], request=self.context["request"]
+            )
+        }
+
+    class Meta:
+        model = Stadium
+        fields = (
+            "id",
+            "name",
+            "total_capacity",
+            "seating_capacity",
+            "standing_capacity",
+            "guest_rating",
+            "city",
+            "_city",
+        )
+
+
+class StadiumRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:stadium-detail")
+
+    class Meta:
+        model = Stadium
+        fields = ("id", "name", "_detail")

wbcore/contrib/example_app/serializers/teamresult.py

@@ -0,0 +1,44 @@
+from enum import Enum
+
+from django.forms import ValidationError
+from django.utils.translation import gettext as _
+
+from wbcore import serializers
+from wbcore.contrib.example_app.models import League, Team, TeamResults
+from wbcore.contrib.example_app.serializers import (
+    LeagueRepresentationSerializer,
+    TeamRepresentationSerializer,
+)
+
+
+class ResultErrorMessages(Enum):
+    result_exists = _("Results for this team and league already exist.")
+
+
+class TeamResultsModelSerializer(serializers.ModelSerializer):
+    _team = TeamRepresentationSerializer(source="team")
+    _league = LeagueRepresentationSerializer(source="league")
+    games_played = serializers.IntegerField(label=_("Games"), default=0)
+
+    def validate(self, data: dict) -> dict:
+        team: Team | None = data.get("team", None)
+        league: League | None = data.get("league", None)
+        if team and league:
+            team_results = TeamResults.objects.filter(team=team, league=league)
+            if obj := self.instance:
+                team_results = team_results.exclude(id=obj.id)
+            if team_results.exists():
+                raise ValidationError({"team": ResultErrorMessages.result_exists.value})
+        return super().validate(data)
+
+    class Meta:
+        model = TeamResults
+        fields = "__all__"
+
+
+class TeamResultsRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="example_app:teamresults-detail")
+
+    class Meta:
+        model = TeamResults
+        fields = ("id", "team", "league", "_detail")

wbcore/contrib/example_app/templates/example_app/embedded_view.html

@@ -0,0 +1,19 @@
+<html>
+  <head>
+    <link rel="stylesheet" href="https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/static/{{ FRONTEND_VERSION }}/embedded/main.css">
+  </head>
+  <body>
+    <h1>Embedded View Example</h1>
+    <div style="display: flex; flex-direction: row;">
+      <div style="width: 70%; height: 750px;" data-wb-endpoint="{% url 'example_app:player-list' %}" data-wb-hide-control-bar data-wb-lazy-load></div>
+      <div style="width: 30%; height: 750px;" data-wb-endpoint="{% url 'example_app:player-detail' 37 %}" data-wb-hide-control-bar></div>
+    </div>
+    <div style="height: 750px;" data-wb-endpoint="{% url 'example_app:player-statistics-list' 37 %}" data-wb-hide-control-bar></div>
+    <div style="height: 750px;" data-wb-endpoint="{% url 'example_app:team-list' %}" data-wb-lazy-load></div>
+    <div style="height: 750px;" data-wb-endpoint="{% url 'example_app:stadium-list' %}" data-wb-hide-control-bar data-wb-lazy-load data-wb-lazy-load-threshold="500"></div>
+    <script>window.wbcore_config_url = 'https://staging.atonra.stainly-bench.com/wbcore/config/'</script>
+    <script src="{{ PLOTLY_CDN }}" charset="utf-8"></script>
+    <script src="https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/static/{{ FRONTEND_VERSION }}/embedded/embeddedWbView-runtime.umd.js" type="module"></script>
+    <script src="https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/static/{{ FRONTEND_VERSION }}/embedded/embeddedWbView-main.umd.js" type="module"></script>
+  </body>
+</html>

wbcore/contrib/example_app/tests/conftest.py

@@ -0,0 +1,13 @@
+import pytest
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from wbcore.contrib.example_app.tests.signals import app_pre_migration
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("geography"))
+
+
+@pytest.fixture
+def chrome_options(chrome_options):
+    chrome_options.add_argument("--headless=new")
+    chrome_options.add_argument("--disable-extensions")
+    return chrome_options

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

@@ -0,0 +1 @@
+from .e2e_example_app_utility import create_new_league_instance, create_new_team_instance, create_new_person_instance

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

@@ -0,0 +1,52 @@
+from selenium.webdriver.remote.webdriver import WebDriver
+
+from wbcore.contrib.example_app.factories import (
+    LeagueFactory,
+    SportPersonFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.models import League, Sport, Team
+from wbcore.contrib.example_app.serializers import (
+    LeagueModelSerializer,
+    SportPersonModelSerializer,
+    TeamModelSerializer,
+)
+from wbcore.test import (
+    click_element_by_path,
+    fill_out_form_fields,
+    open_create_instance,
+)
+
+
+def create_new_league_instance(
+    driver: WebDriver, field_list: list[str], sport: Sport, is_create_instance_open=True
+) -> League:
+    if not is_create_instance_open:
+        open_create_instance(driver, "Sports App", create_instance_title="Create League")
+
+    league: dict = LeagueFactory.build(sport=sport)
+    serializer = LeagueModelSerializer(league)
+    fill_out_form_fields(driver, serializer, field_list, league)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return league
+
+
+def create_new_team_instance(driver: WebDriver, field_list: list[str], is_create_instance_open=True) -> Team:
+    if not is_create_instance_open:
+        open_create_instance(driver, "Sports App", create_instance_title="Create Team")
+
+    team: dict = TeamFactory.build()
+    serializer = TeamModelSerializer(team)
+    fill_out_form_fields(driver, serializer, field_list, team)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return team
+
+
+def create_new_person_instance(driver: WebDriver, field_list: list[str], is_create_instance_open=True):
+    if not is_create_instance_open:
+        open_create_instance(driver, "Sports App", "Persons", create_instance_title="Create Person")
+    person: dict = SportPersonFactory.build()
+    serializer = SportPersonModelSerializer(person)
+    fill_out_form_fields(driver, serializer, field_list, person)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return person

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

@@ -0,0 +1,70 @@
+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.factories import SportFactory
+from wbcore.contrib.example_app.models import League
+from wbcore.contrib.example_app.serializers import LeagueModelSerializer
+from wbcore.contrib.example_app.tests.e2e import create_new_league_instance
+from wbcore.test import (
+    click_button_by_label,
+    click_new_button,
+    delete_list_entry,
+    edit_list_instance,
+    is_counter_as_expected,
+    is_error_visible,
+    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 TestLeague:
+    def test_create_edit_delete_league(self, live_server, selenium):
+        # Creating a test user and login to the WB
+        user: User = SuperUserFactory.create(plaintext_password=USER_PASSWORD)
+        actions = ActionChains(selenium, 1000)
+        set_up(selenium, live_server, user.email, USER_PASSWORD)
+
+        # -----> CREATE A NEW LEAGUE <----- #
+        sport = SportFactory.create()
+        league_a = create_new_league_instance(
+            selenium, ["name", "sport", "established_date", "points_per_win"], sport, False
+        )
+        open_menu_item(selenium, "Leagues", perform_mouse_move=True)
+
+        assert is_counter_as_expected(selenium, League.objects.count())
+        assert is_text_visible(selenium, league_a.name)
+
+        # Trying to create a league without filling out anything -> We expect an error to be thrown.
+        click_new_button(selenium)
+        assert is_text_visible(selenium, "Create League")
+        click_button_by_label(selenium, "Save and close")
+        assert is_error_visible(selenium)
+
+        league_b = create_new_league_instance(
+            selenium, ["name", "sport", "established_date", "points_per_win"], sport, True
+        )
+
+        assert is_counter_as_expected(selenium, League.objects.count())
+        assert is_text_visible(selenium, league_b.name)
+
+        # ------> EDIT A NEW LEAGUE <------ #
+
+        edit_list_instance(selenium, actions, league_a.name, LeagueModelSerializer(league_a), {"name": "Fun League"})
+        assert is_string_not_visible(selenium, league_a.name)
+        assert is_text_visible(selenium, "Fun League")
+        assert is_counter_as_expected(selenium, League.objects.count())
+
+        # -----> Delete <----- #
+
+        delete_list_entry(selenium, actions, league_b.name)
+        assert is_counter_as_expected(selenium, League.objects.count())
+        assert is_text_visible(selenium, "Fun League")
+        assert is_string_not_visible(selenium, league_b.name)