wbcore 2.2.1__py2.py3-none-any.whl

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,6 @@
+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,10 @@
+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,37 @@
+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,12 @@
+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,17 @@
+def get_columns(cursor):
+    return [col[0] for col in cursor.description or []]
+
+
+def dictfetchall(cursor):
+    """
+    Return all rows from a cursor as a dict.
+    Assume the column names are unique.
+    """
+    columns = get_columns(cursor)
+    for row in cursor.fetchall():
+        yield dict(zip(columns, row))
+
+
+def dictfetchone(cursor):
+    columns = get_columns(cursor)
+    return dict(zip(columns, cursor.fetchone() or []))

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,54 @@
+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",
+    )
+
+
+@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,230 @@
+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 = {
+            "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 = {
+            "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,8 @@
+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,69 @@
+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()

wbcore/contrib/directory/dynamic_preferences_registry.py

@@ -0,0 +1,61 @@
+import pycountry
+from django.forms import ValidationError
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import IntegerPreference, StringPreference
+
+from .models.entries import Company
+
+general = Section("directory")
+
+
+@global_preferences_registry.register
+class MainCompanyPreference(IntegerPreference):
+    section = general
+    name = "main_company"
+    default = 0
+
+    verbose_name = _("Main Workbench Company")
+    help_text = _(
+        'The main company of the Workbench. All employees of this company are considered to have "employee" status and have more permissions than other users.'
+    )
+
+    def validate(self, value):
+        if not Company.objects.filter(id=value).exists():
+            raise ValidationError(_("Please select a valid company."))
+
+
+@global_preferences_registry.register
+class CountryCodePreference(StringPreference):
+    section = general
+    name = "main_country_code"
+    default = "US"
+    verbose_name = _("Main Country Code")
+    help_text = _(
+        "Determines the country code currently used exclusively for parsing of phone numbers. Should be the country where the phone number is being dialled from."
+    )
+
+    def validate(self, value):
+        if not pycountry.countries.get(alpha_2=value):
+            raise ValidationError(_("Only exact alpha_2 country codes (e.g. DE, CH) allowed."))
+
+
+@global_preferences_registry.register
+class PersonSalutationStringPreference(StringPreference):
+    section = general
+    name = "person_salutation"
+    default = _("Dear {0} {1}")
+
+    verbose_name = _("Person Salutation")
+    help_text = _("Salutation that can be used in mails for a person")
+
+
+@global_preferences_registry.register
+class CompanySalutationStringPreference(StringPreference):
+    section = general
+    name = "company_salutation"
+    default = _("To everyone from {0}")
+
+    verbose_name = _("Company Salutation")
+    help_text = _("Salutation that can be used in mails for a company")