wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/dataloader/models/querysets/entities.py

@@ -0,0 +1,28 @@
+from django.db import models
+
+from wbcore.contrib.dataloader.dataloaders.proxies import DataloaderProxy
+
+
+class EntityQuerySet(models.QuerySet):
+    """A custom QuerySet for entities that provides an interface to a dataloader proxy.
+
+    This QuerySet subclass adds a method to interact with the associated dataloader
+    proxy. It is designed to be used with models that inherit from the `Entity` class,
+    providing a streamlined way to access dataloader functionality directly from
+    QuerySet instances.
+    """
+
+    @property
+    def dl(self) -> DataloaderProxy:
+        """Provides access to the dataloader proxy for the entities in the QuerySet.
+
+        This method allows for easy retrieval of the DataloaderProxy instance
+        associated with the QuerySet. It enables the utilization of dataloader
+        functionalities directly from the QuerySet, facilitating data fetching and
+        processing tasks.
+
+        Returns:
+            DataloaderProxy: An instance of DataloaderProxy associated with the
+                entities in the QuerySet.
+        """
+        return self.model.dl_proxy(self)

wbcore/contrib/dataloader/tests/conftest.py

@@ -0,0 +1,26 @@
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+
+from .test.factories import EntityTestFactory
+
+
+def app_pre_migration(sender, app_config, **kwargs):
+    cur = connection.cursor()
+    cur.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gin;")
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gist;")
+
+
+pre_migrate.connect(app_pre_migration)
+register(EntityTestFactory)
+register(
+    EntityTestFactory,
+    "entity_test_over_1000",
+    dl_parameters={
+        "data": {
+            "path": "wbcore.contrib.dataloader.tests.test.dataloaders.dataloaders.RandomDataOver1000",
+            "parameters": {},
+        }
+    },
+)

wbcore/contrib/dataloader/tests/test/dataloaders/dataloaders.py

@@ -0,0 +1,18 @@
+import random
+from typing import Iterator
+
+from wbcore.contrib.dataloader.dataloaders import Dataloader
+
+from .protocols import EntityTestDataProtocol
+
+
+class RandomData(EntityTestDataProtocol, Dataloader):
+    def data(self, n: int) -> Iterator[int]:
+        for _ in self.entities:
+            yield from map(lambda x: random.randint(0, 1000), range(n))
+
+
+class RandomDataOver1000(EntityTestDataProtocol, Dataloader):
+    def data(self, n: int) -> Iterator[int]:
+        for _ in self.entities:
+            yield from map(lambda x: random.randint(1000, 10000), range(n))

wbcore/contrib/dataloader/tests/test/dataloaders/protocols.py

@@ -0,0 +1,5 @@
+from typing import Iterator, Protocol
+
+
+class EntityTestDataProtocol(Protocol):
+    def data(self, n: int) -> Iterator[int]: ...

wbcore/contrib/dataloader/tests/test/dataloaders/proxies.py

@@ -0,0 +1,11 @@
+from typing import Iterator
+
+from wbcore.contrib.dataloader.dataloaders import DataloaderProxy
+
+from .protocols import EntityTestDataProtocol
+
+
+class EntityTestDataloaderProxy(DataloaderProxy[EntityTestDataProtocol]):
+    def data(self, n: int) -> Iterator[int]:
+        for dl in self.iterate_dataloaders("data"):
+            yield from dl.data(n)

wbcore/contrib/dataloader/tests/test/factories.py

@@ -0,0 +1,13 @@
+import factory
+
+from .models import EntityTest
+
+
+class EntityTestFactory(factory.django.DjangoModelFactory):
+    dl_parameters = {
+        "data": {"path": "wbcore.contrib.dataloader.tests.test.dataloaders.dataloaders.RandomData", "parameters": {}}
+    }
+    name = factory.Faker("pystr")
+
+    class Meta:
+        model = EntityTest

wbcore/contrib/dataloader/tests/test/models.py

@@ -0,0 +1,11 @@
+from django.db import models
+
+from wbcore.contrib.dataloader.models import Entity
+from wbcore.contrib.dataloader.tests.test.dataloaders.proxies import (
+    EntityTestDataloaderProxy,
+)
+
+
+class EntityTest(Entity):
+    dl_proxy = EntityTestDataloaderProxy
+    name = models.CharField(max_length=255)

wbcore/contrib/dataloader/tests/test_dataloaders.py

@@ -0,0 +1,38 @@
+from typing import Iterator
+
+import pytest
+
+from wbcore.contrib.dataloader.tests.test.dataloaders.proxies import (
+    EntityTestDataloaderProxy,
+)
+from wbcore.contrib.dataloader.tests.test.models import EntityTest
+
+
+@pytest.mark.django_db
+class TestEntityTestDataloader:
+    def test_dataloader_proxy(self, entity_test):
+        dl_proxy = EntityTest.objects.filter(id=entity_test.id).dl
+        assert isinstance(dl_proxy, EntityTestDataloaderProxy), "The proxy should exist"
+
+    def test_dataloader(self, entity_test):
+        result = EntityTest.objects.filter(id=entity_test.id).dl.data(10)
+        assert isinstance(result, Iterator), "The result of a dataloader should be an iterator"
+        assert len(list(result)) == 10, "The result should have a length of 10 items"
+        assert all(isinstance(item, int) for item in result), "All items in the result list should be integers"
+
+    def test_multiple_entries_dataloader(self, entity_test_factory):
+        entity_test_factory.create()
+        entity_test_factory.create()
+        entity_test_factory.create()
+        result = EntityTest.objects.all().dl.data(10)
+        assert len(list(result)) == 30, "The result should have a length of 30 (3 EntityTest x 10) items"
+
+    def test_multiple_dataloader(self, entity_test, entity_test_over_1000):
+        result = EntityTest.objects.all().dl.data(10)
+        assert (
+            len(list(result)) == 20
+        ), "The result should have a length of 20 (1 EntityTest x 2 Dataloader x 10) items"
+
+    def test_empty_dataloader(self):
+        result = list(EntityTest.objects.all().dl.data(10))
+        assert len(result) == 0, "Having no entities, should result in an empty list"

wbcore/contrib/dataloader/tests/test_entities.py

@@ -0,0 +1,13 @@
+import pytest
+
+from wbcore.contrib.dataloader.tests.test.models import EntityTest
+
+
+@pytest.mark.django_db
+class TestEntities:
+    def test_entity_factory(self, entity_test):
+        assert entity_test.id, "The Test Entity should have an id if the factory created it"
+
+    def test_entity_creation(self):
+        entity_test = EntityTest.objects.create(name="test", dl_parameters={"data": {"path": "abc", "parameters": {}}})
+        assert entity_test.id, "It should be possible to create an EntityTest model"

wbcore/contrib/dataloader/utils.py

@@ -0,0 +1,20 @@
+from typing import TYPE_CHECKING, Iterator
+
+if TYPE_CHECKING:
+    from django.db.backends.utils import CursorWrapper
+
+
+def get_columns(cursor: "CursorWrapper") -> list[str]:
+    return [col[0] for col in cursor.description or []]
+
+
+def dictfetchall[T](cursor: "CursorWrapper", dict_type: type[T] = dict) -> Iterator[T]:
+    columns = get_columns(cursor)
+    for row in cursor.fetchall():
+        # The spec for TypedDict is not compliant with the sepc for dict
+        yield dict_type(zip(columns, row, strict=False))  # type: ignore
+
+
+def dictfetchone(cursor: "CursorWrapper") -> dict:
+    columns = get_columns(cursor)
+    return dict(zip(columns, cursor.fetchone() or [], strict=False))

wbcore/contrib/directory/admin/__init__.py

@@ -0,0 +1,14 @@
+from .contacts import *
+from .entries import (
+    CompanyAdmin,
+    CompanyTypeAdmin,
+    CustomerStatusAdmin,
+    EntryAdmin,
+    PersonAdmin,
+)
+from .relationships import (
+    EmployerEmployeeRelationshipAdmin,
+    PositionAdmin,
+    RelationshipModelAdmin,
+    RelationshipTypeModelAdmin,
+)

wbcore/contrib/directory/admin/contacts.py

@@ -0,0 +1,55 @@
+from django.contrib import admin
+
+from ..models import (
+    AddressContact,
+    BankingContact,
+    EmailContact,
+    SocialMediaContact,
+    TelephoneContact,
+    WebsiteContact,
+)
+
+
+@admin.register(TelephoneContact)
+class TelephoneContactModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = ("entry__computed_str", "number")
+
+
+@admin.register(WebsiteContact)
+class WebsiteContactModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = ("entry__computed_str", "url")
+
+
+@admin.register(EmailContact)
+class EmailContactModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = ("entry__computed_str", "address")
+
+
+@admin.register(AddressContact)
+class AddressContactModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = (
+        "entry__computed_str",
+        "street",
+        "street_additional",
+        "zip",
+        "geography_city__name",
+        "geography_city__parent__name",
+        "geography_city__parent__parent__name",
+    )
+    raw_id_fields = ["geography_city"]
+
+
+@admin.register(SocialMediaContact)
+class SocialMediaContact(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = ("entry__computed_str", "platform")
+
+
+@admin.register(BankingContact)
+class BankingContactModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("entry",)
+    search_fields = ("entry__computed_str", "institute", "institute_additional", "iban", "swift_bic")

wbcore/contrib/directory/admin/entries.py

@@ -0,0 +1,235 @@
+import re
+
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+from reversion.admin import VersionAdmin
+
+from wbcore.admin import ExportCsvMixin, ImportCsvMixin
+
+from ..models import (
+    AddressContact,
+    BankingContact,
+    Company,
+    CompanyType,
+    CustomerStatus,
+    EmailContact,
+    Entry,
+    Person,
+    SocialMediaContact,
+    Specialization,
+    TelephoneContact,
+    WebsiteContact,
+)
+
+
+@admin.register(CustomerStatus)
+class CustomerStatusAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+@admin.register(CompanyType)
+class CompanyTypeAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+@admin.register(Specialization)
+class SpecializationAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+class AddressContactInline(admin.StackedInline):
+    model = AddressContact
+    raw_id_fields = ["entry", "geography_city"]
+    extra = 0
+
+
+class BankingContactInline(admin.StackedInline):
+    model = BankingContact
+    extra = 0
+    raw_id_fields = ["entry", "currency"]
+    autocomplete_fields = ["currency"]
+
+
+class EmailContactInline(admin.StackedInline):
+    model = EmailContact
+    extra = 0
+    raw_id_fields = ["entry"]
+
+
+class TelephoneContactInline(admin.StackedInline):
+    model = TelephoneContact
+    extra = 0
+    raw_id_fields = ["entry"]
+
+
+class WebsiteContactInline(admin.StackedInline):
+    model = WebsiteContact
+    extra = 0
+    raw_id_fields = ["entry"]
+
+
+class SocialMediaContactInline(admin.StackedInline):
+    model = SocialMediaContact
+    extra = 0
+    raw_id_fields = ["entry"]
+
+
+class EmployeesInline(admin.StackedInline):
+    model = Person
+    extra = 0
+    raw_id_fields = ["entry", "employers", "specializations"]
+
+
+@admin.register(Entry)
+class EntryAdmin(ExportCsvMixin, ImportCsvMixin, VersionAdmin):
+    list_display = ("computed_str", "entry_type", "is_active")
+    fieldsets = ((_("Main information"), {"fields": ("computed_str", "is_active")}),)
+    search_fields = ("computed_str",)
+    raw_id_fields = ("relationship_managers",)
+    inlines = [
+        EmployeesInline,
+        AddressContactInline,
+        BankingContactInline,
+        EmailContactInline,
+        TelephoneContactInline,
+        WebsiteContactInline,
+        SocialMediaContactInline,
+    ]
+
+    def reversion_register(self, model, **options):
+        options = {}
+        if issubclass(model, Entry):
+            options = {
+                "follow": (
+                    "relationship_managers",
+                    "relationships",
+                )
+            }
+
+        super().reversion_register(model, **options)
+
+    def get_queryset(self, request):
+        return self.model.all_objects.all()
+
+
+@admin.register(Company)
+class CompanyAdmin(EntryAdmin):
+    fieldsets = (
+        (_("Main information"), {"fields": ("name", "computed_str", "slugify_computed_str", "is_active")}),
+        (
+            _("Additional Fields"),
+            {"fields": ("headcount", "tier", "activity_heat", "salutation")},
+        ),
+        (_("System-Files"), {"fields": ("profile_image",)}),
+    )
+
+    def reversion_register(self, model, **options):
+        super().reversion_register(model, **options)
+
+    def process_model(self, model):
+        managers = []
+        if model.get("relationship_managers", None):
+            managers = [Person.objects.get(id=person) for person in model.get("relationship_managers").split(",")]
+            del model["relationship_managers"]
+
+        obj = self.model.objects.create(**model)
+        if managers:
+            obj.relationship_managers.add(*managers)
+
+
+@admin.register(Person)
+class PersonAdmin(EntryAdmin):
+    search_fields = ("first_name", "last_name")
+    list_display = ("first_name", "last_name", "is_active")
+    fieldsets = (
+        (
+            _("Main information"),
+            {"fields": ("first_name", "last_name", "computed_str", "slugify_computed_str", "is_active")},
+        ),
+        (_("Work Fields"), {"fields": ("active_employee",)}),
+        (
+            _("Additional Fields"),
+            {"fields": ("additional_fields",)},
+        ),
+        (_("Misc."), {"fields": ("birthday",)}),
+        (
+            _("System-Files"),
+            {
+                "fields": (
+                    "profile_image",
+                    "signature",
+                )
+            },
+        ),
+        (_("Activity Heat"), {"fields": ("activity_heat",)}),
+    )
+
+    def _get_base_fields(self):
+        return [f.name for f in self.model._meta.get_fields()]
+
+    def get_import_fields(self):
+        emails_fields = [f"email__{e.name}" for e in EmailContact._meta.get_fields()]
+        telephone_fields = [f"telephone__{t.name}" for t in TelephoneContact._meta.get_fields()]
+
+        return emails_fields + telephone_fields + self._get_base_fields()
+
+    def reversion_register(self, model, **options):
+        options = {}
+        if issubclass(self.model, Entry):
+            options = {
+                "follow": (
+                    "employers",
+                    "objects",
+                    "employees",
+                )
+            }
+        super().reversion_register(model, **options)
+
+    def process_model(self, model):
+        employer = relationship_managers = None
+
+        # Extract reverse relation ship (i.e. person's contacts)
+        email = {}
+        delete_keys = set()
+        for k in model.keys():
+            m = re.search("email__(.+)", k)
+            if m:
+                email[m.group(1)] = model[k]
+                delete_keys.add(k)
+
+        telephone = {}
+        for k in model.keys():
+            m = re.search("telephone__(.+)", k)
+            if m:
+                telephone[m.group(1)] = model[k]
+                delete_keys.add(k)
+        for key in delete_keys:
+            del model[key]
+        # Sanitize Foreign keys
+        if model.get("employers", None):
+            employer, created = Company.objects.get_or_create(name=model["employers"])
+            del model["employers"]
+        if model.get("relationship_managers", None):
+            relationship_managers = Person.objects.get(id=model["relationship_managers"])
+            del model["relationship_managers"]
+
+        # Filter non-model fields
+        model = dict(filter(lambda elem: elem[0] in self._get_base_fields(), model.items()))
+        qs = self.model.objects.filter(first_name=model["first_name"], last_name=model["last_name"])
+        if qs.exists():
+            obj = qs.first()
+        else:
+            obj = self.model.objects.create(**model)
+
+        # Create reverse relationship
+        if employer:
+            obj.employers.add(employer)
+        if relationship_managers:
+            obj.relationship_managers.add(relationship_managers)
+        if telephone and telephone.get("number", None):
+            TelephoneContact.objects.get_or_create(entry=obj, number=telephone["number"], defaults=telephone)
+        if email and email.get("address", None):
+            EmailContact.objects.get_or_create(entry=obj, address=email["address"], defaults=email)

wbcore/contrib/directory/admin/relationships.py

@@ -0,0 +1,73 @@
+from django.contrib import admin
+from django.db.models import Q
+from django.forms import ModelForm
+from reversion.admin import VersionAdmin
+
+from ..models import (
+    ClientManagerRelationship,
+    EmployerEmployeeRelationship,
+    Position,
+    Relationship,
+    RelationshipType,
+)
+
+
+@admin.register(Position)
+class PositionAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+@admin.register(Relationship)
+class RelationshipModelAdmin(VersionAdmin):
+    list_display = ("id", "relationship_type", "from_entry", "to_entry")
+    autocomplete_fields = ("relationship_type",)
+
+    def reversion_register(self, model, **options):
+        options = {
+            "follow": (
+                "from_entry",
+                "to_entry",
+                "relationship_type",
+            )
+        }
+        super().reversion_register(model, **options)
+
+
+class RelationshipTypeModelAdminForm(ModelForm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["counter_relationship"].queryset = RelationshipType.objects.filter(
+            ~Q(id=self.instance.id) & (Q(counter_relationship=self.instance) | Q(counter_relationship=None))
+        )
+
+
+@admin.register(RelationshipType)
+class RelationshipTypeModelAdmin(VersionAdmin):
+    form = RelationshipTypeModelAdminForm
+    list_display = ("title", "counter_relationship")
+    search_fields = ("title",)
+
+    def reversion_register(self, model, **options):
+        options = {"follow": ("counter_relationship",)}
+        super().reversion_register(model, **options)
+
+
+@admin.register(ClientManagerRelationship)
+class ClientManagerRelationshipModelAdmin(VersionAdmin):
+    search_fields = ("relationship_manager__computed_str", "client__computed_str")
+    list_display = ("id", "relationship_manager", "client", "primary", "status", "created")
+
+    def reversion_register(self, model, **options):
+        options = {
+            "follow": (
+                "client",
+                "relationship_manager",
+            )
+        }
+        super().reversion_register(model, **options)
+
+
+@admin.register(EmployerEmployeeRelationship)
+class EmployerEmployeeRelationshipAdmin(admin.ModelAdmin):
+    list_display = ("id", "employer", "employee", "primary", "position", "position_name")

wbcore/contrib/directory/apps.py

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

wbcore/contrib/directory/configs.py

@@ -0,0 +1,9 @@
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+
+from wbcore.configs.decorators import register_config
+
+
+@register_config
+def profile_config(request: Request) -> tuple[str, str]:
+    return "profile", reverse("wbcore:profile", request=request)

wbcore/contrib/directory/configurations.py

@@ -0,0 +1,70 @@
+from django.utils.translation import gettext_lazy
+from rest_framework.reverse import reverse
+
+from wbcore.utils.importlib import import_from_dotted_path
+
+
+class ConfigurationRegistry:
+    DEFAULT_COMPANY_MODEL_VIEWSET = "wbcore.contrib.directory.viewsets.entries.CompanyModelViewSet"
+    DEFAULT_COMPANY_REPRESENTATION_VIEWSET = "wbcore.contrib.directory.viewsets.entries.CompanyRepresentationViewSet"
+    DEFAULT_COMPANY_MODEL_SERIALIZER = "wbcore.contrib.directory.serializers.companies.CompanyModelSerializer"
+    DEFAULT_COMPANY_REPRESENTATION_SERIALIZER = (
+        "wbcore.contrib.directory.serializers.entries.CompanyRepresentationSerializer"
+    )
+    DEFAULT_PERSON_MODEL_VIEWSET = "wbcore.contrib.directory.viewsets.entries.PersonModelViewSet"
+    DEFAULT_PERSON_REPRESENTATION_VIEWSET = "wbcore.contrib.directory.viewsets.entries.PersonRepresentationViewSet"
+    DEFAULT_PERSON_MODEL_SERIALIZER = "wbcore.contrib.directory.serializers.persons.PersonModelSerializer"
+    DEFAULT_PERSON_REPRESENTATION_SERIALIZER = (
+        "wbcore.contrib.directory.serializers.entries.PersonRepresentationSerializer"
+    )
+
+    @property
+    def company_model_viewset(self):
+        return import_from_dotted_path(self.DEFAULT_COMPANY_MODEL_VIEWSET)
+
+    @property
+    def company_representation_viewset(self):
+        return import_from_dotted_path(self.DEFAULT_COMPANY_REPRESENTATION_VIEWSET)
+
+    @property
+    def company_model_serializer(self):
+        return import_from_dotted_path(self.DEFAULT_COMPANY_MODEL_SERIALIZER)
+
+    @property
+    def company_representation_serializer(self):
+        return import_from_dotted_path(self.DEFAULT_COMPANY_REPRESENTATION_SERIALIZER)
+
+    @property
+    def person_model_viewset(self):
+        return import_from_dotted_path(self.DEFAULT_PERSON_MODEL_VIEWSET)
+
+    @property
+    def person_representation_viewset(self):
+        return import_from_dotted_path(self.DEFAULT_PERSON_REPRESENTATION_VIEWSET)
+
+    @property
+    def person_model_serializer(self):
+        return import_from_dotted_path(self.DEFAULT_PERSON_MODEL_SERIALIZER)
+
+    @property
+    def person_representation_serializer(self):
+        return import_from_dotted_path(self.DEFAULT_PERSON_REPRESENTATION_SERIALIZER)
+
+
+class DirectoryConfigurationMixin:
+    WBCORE_PROFILE = "wbcore.contrib.directory.configurations.resolve_profile"
+
+    DEFAULT_TIERING_HELP_TEXT = gettext_lazy(
+        "The tier of the company with 1 being the top tier and 5 being the lowest tier."
+    )
+
+
+def resolve_profile(request):
+    user = request.user
+    return {
+        "image": user.profile.profile_image.url if user.profile.profile_image else None,
+        "endpoint": reverse("wbcore:authentication:userprofile-detail", args=[user.id], request=request),
+    }
+
+
+configuration_registry = ConfigurationRegistry()