wbcore 2.2.3__py2.py3-none-any.whl → 2.2.5__py2.py3-none-any.whl

wbcore/contrib/color/admin.py

@@ -0,0 +1,28 @@
+from django.conf import settings
+from django.contrib import admin
+from django_better_admin_arrayfield.models.fields import ArrayField
+from wbcore.contrib.color.forms import DynamicArrayColorWidget
+from wbcore.contrib.color.models import ColorGradient
+
+
+@admin.register(ColorGradient)
+class ColorGradientModelAdmin(admin.ModelAdmin):
+    class Media:
+        if settings.DEBUG:
+            js = [
+                "colorfield/jscolor/jscolor.js",
+                "colorfield/colorfield.js",
+                "js/django_better_admin_arrayfield.min.js",
+            ]
+        else:
+            js = [
+                "colorfield/jscolor/jscolor.min.js",
+                "colorfield/colorfield.js",
+                "js/django_better_admin_arrayfield.min.js",
+            ]
+        css = {"all": ("css/django_better_admin_arrayfield.min.css",)}
+
+    formfield_overrides = {
+        ArrayField: {"widget": DynamicArrayColorWidget},
+    }
+    list_display = ["title"]

wbcore/contrib/color/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ColorAppConfig(AppConfig):
+    name = "wbcore.contrib.color"

wbcore/contrib/color/enums.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class WBColor(Enum):
+    GREEN_LIGHT = "rgb(214, 229, 145)"
+    GREEN = "rgb(182, 223, 18)"
+    GREEN_DARK = "rgb(111, 181, 68)"
+    RED_LIGHT = "rgb(244, 132, 116)"
+    RED = "rgb(250, 84, 62)"
+    RED_DARK = "rgb(224, 57, 49)"
+    YELLOW_LIGHT = "rgb(247, 232, 113)"
+    YELLOW = "rgb(247, 207, 77)"
+    YELLOW_DARK = "rgb(247, 190, 47)"
+    GREY = "rgb(133, 144, 162)"
+    BLUE_LIGHT = "rgb(104, 198, 224)"
+    BLUE = "rgb(69, 112, 224)"
+    BLUE_DARK = "rgb(33, 26, 233)"

wbcore/contrib/color/factories.py

@@ -0,0 +1,10 @@
+import factory
+from wbcore.contrib.color.models import ColorGradient
+
+
+class ColorGradientFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ColorGradient
+
+    title = factory.Sequence(lambda n: f"Color Gradient {n}")
+    colors = factory.List([factory.Faker("color") for _ in range(10)])

wbcore/contrib/color/fields.py

@@ -0,0 +1,29 @@
+import re
+
+from django.core.exceptions import ValidationError
+from django.db.models import CharField
+
+
+def validate_color(color_string):
+    """Hexadecimal validation."""
+    if color_string is None:
+        return color_string
+
+    if not re.search(r"^#(?:[0-9a-fA-F]{3}){1,2}$", color_string):
+        raise ValidationError("Please provide a valid hexadecimal color.")
+
+    return color_string
+
+
+class ColorField(CharField):
+    description = "A field storing a hexadecimal color value"
+    default_validators = [validate_color]
+
+    def __init__(self, *args, **kwargs):
+        kwargs["max_length"] = 7
+        super().__init__(*args, **kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        del kwargs["max_length"]
+        return name, path, args, kwargs

wbcore/contrib/color/forms.py

@@ -0,0 +1,13 @@
+from django_better_admin_arrayfield.forms.widgets import DynamicArrayWidget
+
+
+class DynamicArrayColorWidget(DynamicArrayWidget):
+    template_name = "wbcore/dynamic_color_array.html"
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        context["default"] = "#ffffff"
+        return context
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

wbcore/contrib/color/models.py

@@ -0,0 +1,62 @@
+from typing import Generator
+
+from colorfield.fields import ColorField
+from django.db import models
+from django_better_admin_arrayfield.models.fields import ArrayField
+
+
+class ColorGradient(models.Model):
+    """
+    Utility class for color gradient support in report
+    """
+
+    title = models.CharField(max_length=128, default="")
+    colors = ArrayField(ColorField(default="#FF0000"), default=list)
+
+    def __str__(self) -> str:
+        return self.title
+
+    def get_gradient(self, color: str | None = None, color_size: int = -1) -> Generator:
+        """
+        Return the consecutive colors (gradient) given a color based on the closest distance
+
+        Args:
+            color: a hex color. Optional.
+            color_size: The number of colors the list should return. Optional.
+
+        Returns:
+            A generator of colors bounds in size by the color_size parameters or the gradient defaults color palette size
+        """
+
+        def _hex2rgb(_color):
+            _color = _color.replace("#", "")
+            return tuple(int(_color[i : i + 2], 16) for i in (0, 2, 4))
+
+        if color_size < 0:
+            color_size = len(self.colors)
+
+        index = 0
+        if color:
+            color_rgb = _hex2rgb(color)
+            nearest_color = min(
+                self.colors, key=lambda subject: sum((s - q) ** 2 for s, q in zip(_hex2rgb(subject), color_rgb))
+            )
+
+            index = self.colors.index(nearest_color)
+        for i in range(color_size):
+            yield self.colors[(index + i) % len(self.colors)]
+
+
+class TransparencyMixin:
+    def get_cell_formatting(self, request):
+        return [
+            {
+                "column": None,
+                "conditions": [
+                    {
+                        "condition": None,
+                        "style": {"backgroundColor": f'rgba(255, 255, 255, {getattr(self, "TRANSPARENCY", 0.4)})'},
+                    },
+                ],
+            }
+        ]

wbcore/contrib/color/tests/conftest.py

@@ -0,0 +1,10 @@
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.color.factories import ColorGradientFactory
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+
+register(ColorGradientFactory)
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("geography"))

wbcore/contrib/color/tests/test_color_models.py

@@ -0,0 +1,61 @@
+import pytest
+from wbcore.contrib.color.factories import ColorGradientFactory
+from wbcore.contrib.color.models import ColorGradient
+
+COLORS = ["#FFFFFF", "#000000", "#FF5733", "#3357FF", "#FF33A1", "#800080"]
+
+
+class TestColorGradientModel:
+    @pytest.mark.django_db
+    def integration_test(self, mocker):
+        gradient = ColorGradientFactory()
+        assert ColorGradient.objects.filter(id=gradient.id).exists()
+
+    def test_str_method(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "title", "My Gradient")
+        assert str(gradient) == "My Gradient"
+
+    def test_default_colors(self):
+        gradient = ColorGradient()
+        assert gradient.colors == []
+
+    def test_get_gradient(self, mocker):
+        gradient = ColorGradient()
+        assert list(gradient.get_gradient()) == []
+
+    def test_get_gradient_no_color_argument(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        palette = list(gradient.get_gradient(color=None, color_size=3))
+        assert len(palette) == 3
+
+    def test_get_gradient_with_non_existent_color(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        non_existent_color = "#123456"
+        palette = list(gradient.get_gradient(color=non_existent_color))
+        assert len(palette) == len(COLORS)
+        assert palette == ["#000000", "#FF5733", "#3357FF", "#FF33A1", "#800080", "#FFFFFF"]
+
+    @pytest.mark.parametrize("color_size", [20, 1, 0, -1])
+    def test_get_gradient_with_different_size(self, color_size, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        palette = list(gradient.get_gradient(color_size=color_size))
+        base_colors = gradient.colors
+        assert len(palette) == color_size if color_size > 0 else len(base_colors)
+        for index, color in enumerate(palette):
+            assert color == base_colors[index % len(base_colors)]
+
+    @pytest.mark.parametrize("color", COLORS)
+    def test_get_gradient_with_different_color(self, color, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        base_colors = gradient.colors
+
+        color_index = base_colors.index(color)
+        palette = list(gradient.get_gradient(color=color))
+
+        assert len(palette) == len(base_colors)
+        assert palette == base_colors[color_index:] + base_colors[:color_index]

wbcore/contrib/color/tests/test_fields.py

@@ -0,0 +1,25 @@
+import pytest
+from django.core.exceptions import ValidationError
+from wbcore.contrib.color.fields import validate_color
+
+
+class TestColorield:
+    @pytest.mark.parametrize(
+        ("input", "valid"),
+        [
+            ("#1234567", False),
+            ("259868", False),
+            ("#25986", False),
+            ("", False),
+            ("#d225b0", True),
+            ("#4839a3", True),
+            ("#259868", True),
+            (None, True),
+        ],
+    )
+    def test_color_validator(self, input, valid):
+        if valid:
+            assert input == validate_color(input)
+        else:
+            with pytest.raises(ValidationError):
+                validate_color(input)

wbcore/contrib/documents/tests/conftest.py

@@ -0,0 +1,30 @@
+import pytest
+from django.apps import apps
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.documents.factories import (
+    DocumentFactory,
+    DocumentTypeFactory,
+    ShareableLinkAccessFactory,
+    ShareableLinkFactory,
+)
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.tests.conftest import *
+
+register(DocumentFactory)
+register(DocumentTypeFactory)
+register(ShareableLinkAccessFactory)
+register(ShareableLinkFactory)
+
+
+@pytest.fixture(
+    autouse=True, scope="session"
+)  # Might want to find a way to registered default conftest logic automatically
+def django_test_environment(django_test_environment):
+    from django.apps import apps
+
+    get_models = apps.get_models
+
+    for m in [m for m in get_models() if not m._meta.managed]:
+        m._meta.managed = True

wbcore/contrib/documents/tests/test_models.py

@@ -0,0 +1,144 @@
+import os
+from datetime import timedelta
+from unittest.mock import patch
+
+import pytest
+from django.core import mail
+from django.core.validators import URLValidator
+from django.utils import timezone
+from faker import Faker
+from slugify import slugify
+from wbcore.contrib.documents.models.documents import (
+    Document,
+    send_email_as_task,
+    upload_to,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestDocumentModel:
+    def test_init(self, document):
+        assert document.id is not None
+
+    @pytest.mark.parametrize(
+        "filename",
+        [(fake.file_name())],
+    )
+    def test_upload_to(self, document, document_type_factory, filename):
+        parent_document_type = document_type_factory.create()
+        document_type = document_type_factory.create(parent=parent_document_type)
+        document.document_type = document_type
+        document.save()
+        assert (
+            upload_to(document, filename)
+            == f"dms/document/{slugify(parent_document_type.name)}/{slugify(document_type.name)}/{filename}"
+        )
+
+    @pytest.mark.parametrize(
+        "document__file",
+        [(fake.file_path())],
+    )
+    def test_filename(self, document):
+        assert document.filename == os.path.basename(document.file.name)
+
+    def test_linked_objects(self, document_factory):
+        document = document_factory.create()
+        link_obj = document_factory.create()
+        document.link(link_obj)
+        assert list(document.linked_objects)[0] == link_obj
+
+    @pytest.mark.parametrize(
+        "sharing_seconds_duration, one_time_link",
+        [(0, False), (fake.pyint(min_value=1), False), (0, True), (fake.pyint(min_value=1), True)],
+    )
+    def test_generate_shareable_link(self, document, sharing_seconds_duration, one_time_link):
+        document.generate_shareable_link(
+            sharing_seconds_duration=sharing_seconds_duration, one_time_link=one_time_link
+        )
+        assert (
+            document.shareable_links.filter(
+                valid_until__isnull=sharing_seconds_duration == 0, one_time_link=one_time_link
+            ).count()
+            == 1
+        )
+
+    @patch("wbcore.contrib.documents.models.documents.send_email_as_task.delay")
+    @pytest.mark.parametrize(
+        "to_emails",
+        [(fake.email())],
+    )
+    def test_send_email(self, mock_fct, document, to_emails):
+        document.send_email(to_emails)
+        assert mock_fct.call_count == 1
+
+    def test_get_for_object(self, document_factory):
+        document = document_factory.create()
+        link_obj = document_factory.create()
+        document.link(link_obj)
+        assert Document.get_for_object(link_obj).first() == document
+
+    @pytest.mark.parametrize(
+        "to_emails, as_link, subject, from_email, body",
+        [
+            (fake.email(), False, None, None, None),
+            (fake.email(), False, fake.paragraph(), fake.email(), fake.paragraph()),
+            (fake.email(), True, None, None, None),
+        ],
+    )
+    def test_send_email_as_task(self, document, to_emails, as_link, subject, from_email, body):
+        assert len(mail.outbox) == 0
+        send_email_as_task(document.id, to_emails, as_link=as_link, subject=subject, from_email=from_email, body=body)
+        assert len(mail.outbox) == 1
+        msg = mail.outbox[0]
+        if as_link:
+            assert document.shareable_links.count() == 1
+            assert len(msg.attachments) == 0
+            assert len(msg.alternatives) == 1
+        else:
+            assert document.shareable_links.count() == 0
+            assert len(msg.attachments) == 1
+            assert len(msg.alternatives) == 2
+        assert msg
+
+
+@pytest.mark.django_db
+class TestDocumentTypeModel:
+    def test_init(self, document_type):
+        assert document_type.id is not None
+
+    def test_str(self, document_type_factory):
+        document_type = document_type_factory.create(parent=document_type_factory.create())
+        document_type.save()
+        assert str(document_type) == document_type.compute_str()
+
+
+@pytest.mark.django_db
+class TestShareableLinkModel:
+    @pytest.mark.parametrize(
+        "shareable_link__manual_invalid, shareable_link__valid_until, shareable_link__one_time_link",
+        [(True, None, False), (False, timezone.now() - timedelta(seconds=60), False), (False, None, True)],
+    )
+    def test_unvalid_link(self, shareable_link):
+        if shareable_link.one_time_link:
+            assert shareable_link.is_valid()
+            shareable_link.access()
+        assert not shareable_link.is_valid()
+
+    def test_link(self, shareable_link):
+        URLValidator()(shareable_link.link)
+
+    def test_access(self, shareable_link):
+        assert shareable_link.accesses.count() == 0
+        shareable_link.access()
+        assert shareable_link.accesses.count() == 1
+
+    def test_init(self, shareable_link):
+        assert shareable_link.id is not None
+
+
+@pytest.mark.django_db
+class TestShareableLinkAccessModel:
+    def test_init(self, shareable_link_access):
+        assert shareable_link_access.id is not None

wbcore/contrib/example_app/tests/test_models/test_event.py

@@ -0,0 +1,87 @@
+import pytest
+from django.db import IntegrityError
+from wbcore.contrib.example_app.factories import (
+    EventFactory,
+    EventTypeFactory,
+    PlayerFactory,
+)
+
+
+@pytest.mark.django_db
+class TestEvent:
+    def test_str(self):
+        event = EventFactory(
+            minute=69,
+            person__first_name="Test",
+            person__last_name="Person",
+            event_type__name="Test Event Type",
+            match__sport__match_duration=90,
+        )
+        assert event.__str__() == "Test Event Type (69.) - Test Person"
+
+    @pytest.mark.parametrize(
+        "home, away, points, home_score, away_score", [(2, 1, 5, 7, 1), (0, 3, 2, 2, 3), (1, 1, 0, 1, 1)]
+    )
+    def test_save_home_scored(self, home, away, points, home_score, away_score):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__home=person.current_team,
+            match__score_home=home,
+            match__score_away=away,
+            event_type__points=points,
+        )
+        assert event.match.score_home == home_score
+        assert event.match.score_away == away_score
+
+    @pytest.mark.parametrize(
+        "home, away, points, home_score, away_score", [(41, 27, 4, 41, 31), (19, 0, 2, 19, 2), (22, 23, 0, 22, 23)]
+    )
+    def test_save_away_scored(self, home, away, points, home_score, away_score):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__away=person.current_team,
+            match__score_home=home,
+            match__score_away=away,
+            event_type__points=points,
+        )
+        assert event.match.score_home == home_score
+        assert event.match.score_away == away_score
+
+    def test_save_no_team(self):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__score_home=2,
+            match__score_away=1,
+            event_type__points=4,
+        )
+        assert event.match.score_home == 2
+        assert event.match.score_away == 1
+
+    def test_save_no_player(self):
+        event = EventFactory(
+            match__score_home=2,
+            match__score_away=1,
+            event_type__points=4,
+        )
+        assert event.match.score_home == 2
+        assert event.match.score_away == 1
+
+    def test_unique_constraint(self):
+        event = EventFactory()
+        with pytest.raises(IntegrityError):
+            EventFactory(person=event.person, minute=event.minute, event_type=event.event_type, match=event.match)
+
+
+@pytest.mark.django_db
+class TestEventType:
+    def test_str(self):
+        event_type = EventTypeFactory(name="Test Event Type")
+        assert event_type.__str__() == "Test Event Type"
+
+    def test_unique_constraint(self):
+        event_type = EventTypeFactory()
+        with pytest.raises(IntegrityError):
+            EventTypeFactory(name=event_type.name, sport=event_type.sport)