wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/directory/serializers/relationships.py

@@ -0,0 +1,332 @@
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy
+from rest_framework.serializers import ValidationError
+from slugify import slugify
+from wbcore import serializers
+from wbcore import serializers as wb_serializers
+
+from ..models import (
+    ClientManagerRelationship,
+    Company,
+    EmployerEmployeeRelationship,
+    Entry,
+    Person,
+    Position,
+    Relationship,
+    RelationshipType,
+)
+from .entries import (
+    CompanyRepresentationSerializer,
+    EntryRepresentationSerializer,
+    PersonRepresentationSerializer,
+)
+
+
+class ClientManagerRelationshipRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:clientmanagerrelationship-detail")
+
+    class Meta:
+        model = ClientManagerRelationship
+        fields = (
+            "id",
+            "computed_str",
+            "_detail",
+        )
+
+
+class RelationshipTypeRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = RelationshipType
+        fields = ("id", "counter_relationship", "title")
+
+
+class RelationshipRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = Relationship
+        fields = (
+            "id",
+            "computed_str",
+        )
+
+
+class PositionRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    endpoint = "wbcore:directory:positionrepresentation-list"
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:position-detail")
+
+    class Meta:
+        model = Position
+        fields = (
+            "id",
+            "title",
+            "_detail",
+        )
+
+
+class PositionModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Position
+        fields = (
+            "id",
+            "title",
+        )
+
+    def validate(self, data):
+        title = data.get("title", None)
+        if title:
+            position = Position.objects.filter(slugify_title=slugify(title, separator=" "))
+            if obj := self.instance:
+                position = position.exclude(id=obj.id)
+            if position.exists():
+                raise ValidationError({"title": _("Cannot add a duplicate position.")})
+        return data
+
+
+class RelationshipTypeModelSerializer(serializers.ModelSerializer):
+    _counter_relationship = RelationshipTypeRepresentationSerializer(source="counter_relationship")
+
+    class Meta:
+        model = RelationshipType
+        fields = (
+            "id",
+            "title",
+            "counter_relationship",
+            "_counter_relationship",
+        )
+
+    def validate(self, data):
+        title = data.get("title", None)
+        if title:
+            type = RelationshipType.objects.filter(slugify_title=slugify(title, separator=" "))
+            if obj := self.instance:
+                type = type.exclude(id=obj.id)
+            if type.exists():
+                raise ValidationError({"title": _("Cannot add duplicate relationship type.")})
+        return data
+
+
+class RelationshipModelSerializer(serializers.ModelSerializer):
+    _relationship_type = RelationshipTypeRepresentationSerializer(source="relationship_type")
+    from_entry = serializers.PrimaryKeyRelatedField(required=False, queryset=Entry.objects.all())
+    _from_entry = EntryRepresentationSerializer(source="from_entry")
+    _to_entry = EntryRepresentationSerializer(source="to_entry")
+
+    class Meta:
+        model = Relationship
+        fields = (
+            "id",
+            "relationship_type",
+            "_relationship_type",
+            "from_entry",
+            "_from_entry",
+            "to_entry",
+            "_to_entry",
+        )
+
+    def validate(self, data):
+        try:
+            if data.get("from_entry"):
+                data["from_entry_id"] = data["from_entry"].id
+            elif self.instance and self.instance.from_entry:
+                data["from_entry_id"] = self.instance.from_entry.id
+            else:
+                data["from_entry_id"] = self.context["view"].kwargs["entry_id"]
+        except KeyError:
+            raise ValidationError(_("From entry has to be set."))
+        from_entry = data.get("from_entry", getattr(self.instance, "from_entry", None))
+        to_entry = data.get("to_entry", getattr(self.instance, "to_entry", None))
+
+        if from_entry == to_entry:
+            msg = _("Cannot add a duplicate relationship type.")
+            raise ValidationError({"from_entry": msg, "to_entry": msg})
+        return super().validate(data)
+
+
+class EmployerEmployeeRelationshipSerializer(serializers.ModelSerializer):
+    _employer = CompanyRepresentationSerializer(source="employer")
+    _employee = PersonRepresentationSerializer(source="employee")
+    _position = PositionRepresentationSerializer(source="position")
+
+    employer_profile_pic = serializers.ImageField(
+        source="employer.profile_image", label=_("Profile Picture"), read_only=True
+    )
+    employee_profile_pic = serializers.ImageField(
+        source="employee.profile_image", label=_("Profile Picture"), read_only=True
+    )
+
+    class Meta:
+        model = EmployerEmployeeRelationship
+        fields = (
+            "id",
+            "primary",
+            "employer",
+            "_employer",
+            "employee",
+            "_employee",
+            "primary",
+            "position",
+            "_position",
+            "employer_profile_pic",
+            "employee_profile_pic",
+            "position_name",
+        )
+        dependency_map = {
+            "position_name": ["position"],
+        }
+
+    def validate(self, data: dict) -> dict:
+        employee: Person | None = data.get("employee", None)
+        employer: Company | None = data.get("employer", None)
+        primary: bool | None = data.get("primary", None)
+
+        if employee and employer and not self.instance:
+            if employer in employee.employers.all():
+                raise ValidationError(
+                    {
+                        "employee": _("{employee} is already an employee of {employer}.").format(
+                            employee=employee.computed_str, employer=employer.computed_str
+                        )
+                    }
+                )
+        elif primary is not None and self.instance:
+            if (
+                EmployerEmployeeRelationship.objects.exclude(id=self.instance.id)
+                .filter(employer=self.instance.employer, employee=self.instance.employee, primary=True)
+                .exists()
+                and primary is False
+            ):
+                raise ValidationError(
+                    {"primary": _("Cannot degrade primary employer. Add a new primary employer instead.")}
+                )
+        return data
+
+
+class ClientManagerModelSerializer(serializers.ModelSerializer):
+    client = serializers.PrimaryKeyRelatedField(
+        queryset=Entry.objects.all(),
+        default=serializers.DefaultFromGET("client"),
+        label=gettext_lazy("Client"),
+        read_only=lambda view: not view.is_modifiable,
+    )
+    _client = EntryRepresentationSerializer(many=False, source="client")
+    relationship_manager = serializers.PrimaryKeyRelatedField(
+        queryset=Person.objects.all(),
+        default=serializers.DefaultFromGET("relationship_manager"),
+        label=gettext_lazy("Relationship Manager"),
+        read_only=lambda view: not view.is_modifiable,
+    )
+    primary = wb_serializers.BooleanField(read_only=lambda view: not view.is_modifiable)
+    _relationship_manager = PersonRepresentationSerializer(many=False, source="relationship_manager")
+
+    def validate(self, data):
+        client = data.get("client", self.instance.client if self.instance else None)
+        relationship_manager = data.get(
+            "relationship_manager", self.instance.relationship_manager if self.instance else None
+        )
+        primary = data.get("primary", self.instance.primary if self.instance else None)
+
+        if not client and not relationship_manager:
+            raise ValidationError(
+                {"client": _("You need to select a client"), "relationship_manager": _("You need to select a manager")}
+            )
+
+        if not client:
+            raise ValidationError({"client": _("You need to select a client")})
+
+        if not relationship_manager:
+            raise ValidationError({"relationship_manager": _("You need to select a manager")})
+
+        if client and relationship_manager:
+            is_primary_manager = ClientManagerRelationship.objects.filter(
+                client=client, relationship_manager=relationship_manager, primary=True
+            ).exists()
+
+            qs = ClientManagerRelationship.objects.filter(
+                relationship_manager=relationship_manager,
+                client=client,
+                status=ClientManagerRelationship.Status.PENDINGADD,
+            )
+            if self.instance:
+                qs = qs.exclude(id=self.instance.id)
+            if qs.exists():
+                raise ValidationError(
+                    {
+                        "non_field_errors": _(
+                            "There is already a pending request to put {manager} in charge of {client}."
+                        ).format(manager=str(relationship_manager), client=client.computed_str)
+                    }
+                )
+
+            qs = ClientManagerRelationship.objects.filter(
+                relationship_manager=relationship_manager, client=client, status=ClientManagerRelationship.Status.DRAFT
+            )
+            if self.instance:
+                qs = qs.exclude(id=self.instance.id)
+            if qs.exists():
+                raise ValidationError(
+                    {
+                        "non_field_errors": _("A draft to put {manager} in charge of {client} already exists.").format(
+                            manager=str(relationship_manager), client=client.computed_str
+                        )
+                    }
+                )
+            if relationship_manager.id == client.id:
+                raise ValidationError(
+                    {"relationship_manager": _("Client and relationship manager cannot be the same person.")}
+                )
+            if relationship_manager in client.relationship_managers.all() and not primary and is_primary_manager:
+                raise ValidationError(
+                    {
+                        "primary": _(
+                            "Cannot degrade primary manager. Make a primary request for a different manager instead."
+                        )
+                    }
+                )
+
+            qs = ClientManagerRelationship.objects.filter(
+                relationship_manager=relationship_manager,
+                client=client,
+                status__in=[ClientManagerRelationship.Status.APPROVED, ClientManagerRelationship.Status.PENDINGREMOVE],
+            )
+            if self.instance:
+                qs = qs.exclude(id=self.instance.id)
+            if qs.exists():
+                raise ValidationError(
+                    {
+                        "non_field_errors": _("{manager} is already in charge of {client}.").format(
+                            manager=str(relationship_manager), client=client.computed_str
+                        )
+                    }
+                )
+        return data
+
+    class Meta:
+        model = ClientManagerRelationship
+        fields = (
+            "id",
+            "status",
+            "client",
+            "_client",
+            "relationship_manager",
+            "_relationship_manager",
+            "created",
+            "primary",
+            "_additional_resources",
+        )
+        read_only_fields = ("created",)
+
+
+class UserIsClientModelSerializer(wb_serializers.ModelSerializer):
+    relationship_manager_name = wb_serializers.CharField(read_only=True, label="Name")
+    relationship_manager_email = wb_serializers.CharField(read_only=True, label="Email")
+    relationship_manager_phone_number = wb_serializers.CharField(read_only=True, label="Phone")
+
+    class Meta:
+        model = ClientManagerRelationship
+        fields = (
+            "id",
+            "primary",
+            "relationship_manager",
+            "relationship_manager_name",
+            "relationship_manager_email",
+            "relationship_manager_phone_number",
+        )

wbcore/contrib/directory/signals.py

@@ -0,0 +1,3 @@
+from django.dispatch import Signal
+
+deactivate_profile = Signal()  # "instance", "substitute_profile"

wbcore/contrib/directory/tests/conftest.py

@@ -0,0 +1,60 @@
+import pytest
+from django.apps import apps
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import InternalUserFactory, UserFactory
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbcore.tests.conftest import *
+
+from ..factories import (
+    AddressContactFactory,
+    BankingContactFactory,
+    ClientFactory,
+    ClientManagerRelationshipFactory,
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EmailContactFactory,
+    EmployersCompanyFactory,
+    EntryFactory,
+    PersonFactory,
+    RelationshipFactory,
+    RelationshipTypeFactory,
+    TelephoneContactFactory,
+    UnemployedPersonFactory,
+    WebsiteContactFactory,
+)
+from .signals import *
+
+register(UserFactory)
+register(EntryFactory)
+register(CompanyFactory)
+register(PersonFactory)
+register(ClientFactory)
+register(InternalUserFactory)
+register(UnemployedPersonFactory)
+register(EmployersCompanyFactory)
+register(BankingContactFactory)
+register(AddressContactFactory)
+register(TelephoneContactFactory)
+register(EmailContactFactory)
+register(WebsiteContactFactory)
+register(ClientManagerRelationshipFactory)
+register(RelationshipFactory)
+register(RelationshipTypeFactory)
+register(CustomerStatusFactory)
+register(CompanyTypeFactory)
+
+
+@pytest.fixture(autouse=True, scope="session")
+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
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("geography"))

wbcore/contrib/directory/tests/disable_signals.py

@@ -0,0 +1,52 @@
+import inspect
+import re
+from collections import defaultdict
+
+from django.db.models.signals import *
+
+
+class DisableSignals(object):
+    def __init__(self, disabled_signals=None):
+        self.stashed_signals = defaultdict(list)
+        self.disabled_signals = disabled_signals or [
+            pre_init,
+            post_init,
+            pre_save,
+            post_save,
+            pre_delete,
+            post_delete,
+            pre_migrate,
+            post_migrate,
+        ]
+
+    def __enter__(self):
+        for signal in self.disabled_signals:
+            self.disconnect(signal)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        for signal in list(self.stashed_signals):
+            self.reconnect(signal)
+
+    def disconnect(self, signal):
+        self.stashed_signals[signal] = signal.receivers
+        signal.receivers = []
+
+    def reconnect(self, signal):
+        signal.receivers = self.stashed_signals.get(signal, [])
+        del self.stashed_signals[signal]
+
+
+# https://stackoverflow.com/questions/55578230/django-how-to-visualize-signals-and-save-overrides
+RECEIVER_MODELS = re.compile(r"sender=(\w+)\W")
+
+
+class DisableSignalsNotification(DisableSignals):
+    def __enter__(self):
+        for signal in self.disabled_signals:
+            if not isinstance(signal, ModelSignal):
+                continue
+            for _, receiver in signal.receivers:
+                rcode = inspect.getsource(receiver())
+                rmodel = RECEIVER_MODELS.findall(rcode)
+                if "Notification" in rmodel:
+                    self.disconnect(signal)

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

@@ -0,0 +1,7 @@
+from .e2e_directory_utility import (
+    set_up_companies,
+    set_up_persons,
+    create_new_company_instance,
+    create_new_cmr_instance,
+    create_new_person_instance,
+)

wbcore/contrib/directory/tests/e2e/e2e_directory_utility.py

@@ -0,0 +1,162 @@
+from selenium.webdriver.remote.webdriver import WebDriver
+from wbcore.contrib.directory.factories import (
+    ClientManagerRelationshipFactory,
+    CompanyFactory,
+    CompanyTypeFactory,
+    CustomerStatusFactory,
+    EmployerEmployeeRelationshipFactory,
+    EntryFactory,
+    PersonFactory,
+    SpecializationFactory,
+)
+from wbcore.contrib.directory.models import (
+    ClientManagerRelationship,
+    Company,
+    CustomerStatus,
+    Person,
+)
+from wbcore.contrib.directory.serializers import (
+    ClientManagerModelSerializer,
+    CompanyModelSerializer,
+    PersonModelSerializer,
+)
+from wbcore.test import (
+    click_element_by_path,
+    fill_out_form_fields,
+    open_create_instance,
+)
+
+# from wbcrm.factories import ActivityFactory
+
+
+def set_up_companies() -> list[Company]:
+    """Creates three companies (called Company A to C), for testing purposes.
+
+    In addition to the three companies, two company types and two activities are created in which the companies participate.\n
+    Company A and Company C are of company type "Type A", Company B is of the type "Type B".\n
+    Company A participates in an Activity that was 15 days ago, Company B and C participate in an Activity that was 60 days ago.
+    """
+    type_a = CompanyTypeFactory(title="Type A")
+    type_b = CompanyTypeFactory(title="Type B")
+    com_a = CompanyFactory(name="Company A", type=type_b)
+    com_b = CompanyFactory(name="Company B", type=type_a)
+    com_c = CompanyFactory(name="Company C", type=type_b)
+    return [com_a, com_b, com_c]
+
+
+def set_up_persons() -> list[Person]:
+    """Creates three persons (called Henry Kalb, Konrad Zuse & Ada Lovelace), for testing purposes."""
+    status_a = CustomerStatusFactory(title="Status A")
+    status_b = CustomerStatusFactory(title="Status B")
+    status_c = CustomerStatusFactory(title="Status C")
+    company_a = CompanyFactory(customer_status=status_a)
+    company_b = CompanyFactory(customer_status=status_b)
+    company_c = CompanyFactory(customer_status=status_c)
+    spec_a = SpecializationFactory(title="Specialization A")
+    spec_b = SpecializationFactory(title="Specialization B")
+    spec_c = SpecializationFactory(title="Specialization C")
+    person_a = PersonFactory(first_name="Henry", last_name="Kalb", prefix=Person.Prefix.MR)
+    person_b = PersonFactory(first_name="Konrad", last_name="Zuse", prefix=Person.Prefix.DR)
+    person_c = PersonFactory(first_name="Ada", last_name="Lovelace", prefix=Person.Prefix.MRS)
+    person_a.specializations.set([spec_a])
+    person_b.specializations.set([spec_b, spec_c])
+    person_c.specializations.set([spec_c])
+    EmployerEmployeeRelationshipFactory(employer=company_a, employee=person_a, primary=True)
+    EmployerEmployeeRelationshipFactory(employer=company_a, employee=person_b, primary=False)
+    EmployerEmployeeRelationshipFactory(employer=company_b, employee=person_b, primary=True)
+    EmployerEmployeeRelationshipFactory(employer=company_c, employee=person_c, primary=True)
+    return [person_a, person_b, person_c]
+
+
+def create_new_company_instance(
+    driver: WebDriver,
+    field_list: list[str],
+    name="Test Company",
+    status_title="Test Status",
+    is_create_instance_open=True,
+) -> Company:
+    """A function that automatically creates a new company for selenium e2e-tests. After creating the instance this function will close the create-widget.
+
+    Args:
+        driver (WebDriver): The Selenium webdriver.
+        field_list (list[str]): List of fields to be filled in the creation mask. The field names must match the names in the CompanyModelSerializer.
+        name (str, optional): The title for the new company instance. Defaults to "Test Company".
+        status_title (str, optional): The status for the new company instance. Defaults to "Test Status".
+        is_create_instance_open (bool, optional): Should be true if the create-widget is already open. Defaults to True.
+
+    Returns:
+        Company: The newly created company.
+    """
+    if not is_create_instance_open:
+        open_create_instance(driver, "CRM", "Create Company")
+
+    if CustomerStatus.objects.filter(title=status_title).exists():
+        status = CustomerStatus.objects.get(title=status_title)
+    else:
+        status = CustomerStatusFactory(title=status_title)
+    company: Company = CompanyFactory.build(name=name, customer_status=status)
+    serializer = CompanyModelSerializer(company)
+
+    fill_out_form_fields(driver, serializer, field_list, company)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return company
+
+
+def create_new_person_instance(
+    driver: WebDriver,
+    field_list: list[str],
+    first_name: str,
+    last_name: str,
+    prefix: str,
+    is_create_instance_open=True,
+) -> Person:
+    """A function that automatically creates a new person for selenium e2e-tests. After creating the instance this function will close the create-widget.
+
+    Args:
+        driver (WebDriver): The Selenium webdriver.
+        field_list (list[str]): List of fields to be filled in the creation mask. The field names must match the names in the PersonModelSerializer.
+        first_name (str): The first name for the newly created person.
+        last_name (str):  The last name for the newly created person.
+        prefix (str):  The prefix for the newly created person.
+        is_create_instance_open (bool, optional): Should be true if the create-widget is already open. Defaults to True.
+
+    Returns:
+        Person: The newly created person.
+    """
+    if not is_create_instance_open:
+        open_create_instance(driver, "CRM", "Create Person")
+
+    person: Person = PersonFactory.build(first_name=first_name, last_name=last_name, prefix=prefix)
+    serializer = PersonModelSerializer(person)
+
+    fill_out_form_fields(driver, serializer, field_list, person)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return person
+
+
+def create_new_cmr_instance(
+    driver: WebDriver,
+    field_list: list[str],
+    is_primary=True,
+    is_create_instance_open=True,
+) -> ClientManagerRelationship:
+    """A function that automatically creates a new client-manager-relationship for selenium e2e-tests. After creating the instance this function will close the create-widget.
+
+    Args:
+        driver (WebDriver): The Selenium webdriver.
+        field_list (list[str]): List of fields to be filled in the creation mask. The field names must match the names in the ClientManagerModelSerializer.
+        is_primary (str): True if the relationship shell be a primary relationship. Defaults to True.
+        is_create_instance_open (bool, optional): Should be true if the create-widget is already open. Defaults to True.
+
+    Returns:
+        ClientManagerRelationship: The newly created CMR.
+    """
+    if not is_create_instance_open:
+        open_create_instance(driver, "CRM", "Create Client Manager Relationship")
+    manager = PersonFactory()
+    entry = EntryFactory()
+    cmr = ClientManagerRelationshipFactory.build(client=entry, relationship_manager=manager, primary=is_primary)
+    serializer = ClientManagerModelSerializer(cmr)
+    fill_out_form_fields(driver, serializer, field_list, cmr)
+    click_element_by_path(driver, "//button[@label='Save and close']")
+    return cmr