wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/directory/serializers/__init__.py

@@ -0,0 +1,62 @@
+from ..configurations import configuration_registry
+
+CompanyModelSerializer = configuration_registry.company_model_serializer
+CompanyRepresentationSerializer = configuration_registry.company_representation_serializer
+PersonModelSerializer = configuration_registry.person_model_serializer
+PersonRepresentationSerializer = configuration_registry.person_representation_serializer
+
+from .companies import (
+    BankModelSerializer,
+    CompanyModelListSerializer,
+    CompanyModelSerializer,
+)
+from .contacts import (
+    AddressContactRepresentationSerializer,
+    AddressContactSerializer,
+    BankingContactRepresentationSerializer,
+    BankingContactSerializer,
+    ReadOnlyBankingContactSerializer,
+    CityRepresentationSerializer,
+    EmailContactRepresentationSerializer,
+    EmailContactSerializer,
+    SocialMediaContactRepresentationSerializer,
+    SocialMediaContactSerializer,
+    TelephoneContactRepresentationSerializer,
+    TelephoneContactSerializer,
+    WebsiteContactRepresentationSerializer,
+    WebsiteContactSerializer,
+)
+from .entries import (
+    CompanyRepresentationSerializer,
+    CompanyTypeModelSerializer,
+    CompanyTypeRepresentationSerializer,
+    CustomerStatusModelSerializer,
+    CustomerStatusRepresentationSerializer,
+    EntryModelSerializer,
+    EntryRepresentationSerializer,
+    InternalUserProfileRepresentationSerializer,
+    PersonRepresentationSerializer,
+    SpecializationModelSerializer,
+    SpecializationRepresentationSerializer,
+)
+from .entry_representations import (
+    EntryRepresentationSerializer,
+    EntryUnlinkedRepresentationSerializer,
+)
+from .persons import (
+    NewPersonModelSerializer,
+    PersonModelListSerializer,
+    PersonModelSerializer,
+)
+from .relationships import (
+    ClientManagerModelSerializer,
+    ClientManagerRelationshipRepresentationSerializer,
+    EmployerEmployeeRelationshipSerializer,
+    PositionModelSerializer,
+    PositionRepresentationSerializer,
+    RelationshipModelSerializer,
+    RelationshipRepresentationSerializer,
+    RelationshipTypeModelSerializer,
+    RelationshipTypeRepresentationSerializer,
+    UserIsClientModelSerializer,
+)

wbcore/contrib/directory/serializers/companies.py

@@ -0,0 +1,169 @@
+from django.conf import settings
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+
+from wbcore import serializers as wb_serializers
+
+from ..models import Company, CustomerStatus, Person
+from .entries import (
+    CompanyTypeRepresentationSerializer,
+    CustomerStatusRepresentationSerializer,
+    EntryModelSerializer,
+    PersonRepresentationSerializer,
+)
+
+
+class CompanyModelSerializer(EntryModelSerializer):
+    customer_status = wb_serializers.PrimaryKeyRelatedField(
+        queryset=CustomerStatus.objects.all(),
+        label=_("Customer Status"),
+    )
+    _customer_status = CustomerStatusRepresentationSerializer(source="customer_status")
+    employees = wb_serializers.PrimaryKeyRelatedField(
+        queryset=Person.objects.all(),
+        default=wb_serializers.DefaultFromGET("employees", many=True),
+        required=False,
+        many=True,
+    )
+    _employees = PersonRepresentationSerializer(source="employees", many=True)
+    is_primary_employer = wb_serializers.BooleanField(read_only=True)
+    tier = wb_serializers.CharField(help_text=settings.DEFAULT_TIERING_HELP_TEXT, label=_("Tier"), required=False)
+    _type = CompanyTypeRepresentationSerializer(source="type")
+
+    @wb_serializers.register_resource()
+    def employees_list(self, instance, request, user):
+        return {"employees": reverse("wbcore:directory:employer-employee-list", args=[instance.id], request=request)}
+
+    class Meta:
+        model = Company
+        read_only_fields = (
+            "activity_heat",
+            "entry_type",
+        )
+        fields = (
+            "id",
+            "computed_str",
+            "activity_heat",
+            "addresses",
+            "cities",
+            "_cities",
+            "customer_status",
+            "_customer_status",
+            "description",
+            "employees",
+            "_employees",
+            "entry_type",
+            "headcount",
+            "is_draft_entry",
+            "is_primary_employer",
+            "name",
+            "primary_address",
+            "primary_email",
+            "primary_manager_repr",
+            "primary_telephone",
+            "primary_website",
+            "primary_social",
+            "profile_image",
+            "salutation",
+            "signature",
+            "tier",
+            "type",
+            "_type",
+            "_additional_resources",
+            "primary_manager",
+            "_primary_manager",
+        )
+
+
+class CompanyModelListSerializer(CompanyModelSerializer):
+    eer_id = wb_serializers.CharField(default="", required=False, read_only=True)
+    is_primary_employer = wb_serializers.BooleanField(read_only=True)
+
+    @wb_serializers.register_resource()
+    def delete(self, instance, request, user):
+        if "view" in request.parser_context:
+            try:
+                person_id = request.parser_context["view"].kwargs.get("person_id", None)
+            except AttributeError:
+                return {}
+            if person_id and instance.eer_id:
+                if not (instance.is_primary_employer is True and len(self.instance) > 1):
+                    return {
+                        "delete": reverse(
+                            "wbcore:directory:employeremployee-delete",
+                            args=[instance.eer_id],
+                            request=request,
+                        )
+                    }
+        return {}
+
+    @wb_serializers.register_resource()
+    def eer_relationship_instance(self, instance, request, user):
+        if "view" in request.parser_context:
+            try:
+                person_id = request.parser_context["view"].kwargs.get("person_id", None)
+            except AttributeError:
+                return {}
+            if person_id and instance.eer_id:
+                return {
+                    "eer_relationship_instance": reverse(
+                        "wbcore:directory:employeremployee-detail",
+                        args=[instance.eer_id],
+                        request=request,
+                    )
+                }
+        return {}
+
+    class Meta:
+        model = Company
+
+        fields = (
+            "id",
+            "name",
+            "activity_heat",
+            "cities",
+            "_cities",
+            "customer_status",
+            "_customer_status",
+            "eer_id",
+            "is_primary_employer",
+            "primary_address",
+            "primary_email",
+            "primary_manager_repr",
+            "primary_telephone",
+            "primary_website",
+            "primary_social",
+            "last_event",
+            "last_event_period_endswith",
+            "tier",
+            "type",
+            "_type",
+            "_additional_resources",
+        )
+
+
+class BankModelSerializer(wb_serializers.ModelSerializer):
+    primary_address = wb_serializers.CharField(
+        allow_null=True, label=_("Primary Address"), read_only=True, required=False
+    )
+    primary_email = wb_serializers.CharField(allow_null=True, label=_("Primary Email"), required=False, read_only=True)
+    primary_telephone = wb_serializers.TelephoneField(
+        allow_null=True, label=_("Primary Telephone"), read_only=True, required=False
+    )
+    _relationship_managers = PersonRepresentationSerializer(many=True, source="relationship_managers")
+
+    def create(self, validated_data: dict) -> Company:
+        validated_data.pop("primary_manager", None)
+        return super().create(validated_data)
+
+    class Meta:
+        model = Company
+        fields = (
+            "id",
+            "name",
+            "primary_address",
+            "primary_email",
+            "primary_telephone",
+            "_relationship_managers",
+            "relationship_managers",
+        )

wbcore/contrib/directory/serializers/contacts.py

@@ -0,0 +1,404 @@
+import phonenumbers
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator, validate_email
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy, pgettext, pgettext_lazy
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from schwifty import BIC, IBAN
+
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.currency.serializers import CurrencyRepresentationSerializer
+from wbcore.contrib.geography.serializers import GeographyRepresentationSerializer
+
+from ..models import (
+    AddressContact,
+    BankingContact,
+    EmailContact,
+    SocialMediaContact,
+    TelephoneContact,
+    WebsiteContact,
+)
+from .entry_representations import EntryRepresentationSerializer
+
+
+class AddressContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:addresscontact-detail")
+    _detail_preview = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:addresscontact-detail")
+
+    geography_city = wb_serializers.CharField(max_length=255, read_only=True)
+    label_key = "{{street}}, {{geography_city}}"
+
+    class Meta:
+        model = AddressContact
+        fields = (
+            "id",
+            "street",
+            "_detail",
+            "_detail_preview",
+            "geography_city",
+        )
+
+
+class CityRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:addresscontact-detail")
+    _detail_preview = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:addresscontact-detail")
+
+    geography_city = wb_serializers.CharField(max_length=255, read_only=True)
+    label_key = "{{geography_city}}"
+
+    class Meta:
+        model = AddressContact
+        fields = (
+            "id",
+            "_detail",
+            "_detail_preview",
+            "geography_city",
+        )
+
+
+class BankingContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _entry = EntryRepresentationSerializer(source="entry")
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:bankingcontact-detail")
+
+    class Meta:
+        model = BankingContact
+        fields = ("id", "_detail", "iban", "institute", "entry", "_entry", "status", "swift_bic")
+
+
+class EmailContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:emailcontact-detail")
+
+    def get_filter_params(self, request):
+        if entry_id := request.parser_context["view"].kwargs.get("entry_id", None):
+            return {"entry": entry_id}
+        return dict()
+
+    class Meta:
+        model = EmailContact
+        fields = ("id", "_detail", "address", "computed_str")
+
+
+class TelephoneContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:telephonecontact-detail")
+
+    class Meta:
+        model = TelephoneContact
+        fields = ("id", "_detail", "number", "primary")
+
+
+class WebsiteContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:websitecontact-detail")
+
+    class Meta:
+        model = WebsiteContact
+        fields = ("id", "_detail", "url")
+
+
+class SocialMediaContactRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:directory:socialmediacontact-detail")
+
+    class Meta:
+        model = SocialMediaContact
+        fields = ("id", "_detail")
+
+
+class EmailContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True)
+    _entry = EntryRepresentationSerializer(source="entry")
+
+    def validate(self, data):
+        address = data.get("address", None)
+        entry = data.get("entry", None)
+        if address and entry:
+            email_contacts = EmailContact.objects.filter(address=address, entry=entry)
+            if obj := self.instance:
+                email_contacts = email_contacts.exclude(id=obj.id)
+            if email_contacts.exists():
+                raise serializers.ValidationError(
+                    {
+                        "address": pgettext(
+                            "Warning for wrong email", "E-Mail address already in use for this {type}."
+                        ).format(type=entry.entry_type.lower())
+                    }
+                )
+        if address:
+            try:
+                validate_email(address)
+            except ValidationError as e:
+                raise serializers.ValidationError({"address": _("Invalid e-mail address")}) from e
+        return data
+
+    class Meta:
+        model = EmailContact
+        fields = (
+            "id",
+            "address",
+            "company_contact",
+            "entry",
+            "_entry",
+            "location",
+            "primary",
+        )
+
+
+class WebsiteContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True)
+    _entry = EntryRepresentationSerializer(source="entry")
+
+    def validate(self, data):
+        url = data.get("url", None)
+        entry = data.get("entry", None)
+        if url and entry:
+            website_contact = WebsiteContact.objects.filter(url=url, entry=entry)
+            if obj := self.instance:
+                website_contact = website_contact.exclude(id=obj.id)
+            if website_contact.exists():
+                raise serializers.ValidationError(
+                    {"url": _("Website already in use for this {type}.").format(type=entry.entry_type.lower())}
+                )
+        return data
+
+    class Meta:
+        model = WebsiteContact
+        fields = ("id", "company_contact", "entry", "_entry", "location", "primary", "url")
+
+
+class AddressContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True)
+    _entry = EntryRepresentationSerializer(source="entry")
+    _geography_city = GeographyRepresentationSerializer(source="geography_city", filter_params={"level": 3})
+    geography_state = wb_serializers.CharField(read_only=True, label=gettext_lazy("State"))
+    geography_country = wb_serializers.CharField(read_only=True, label=gettext_lazy("Country"))
+    geography_continent = wb_serializers.CharField(read_only=True, label=gettext_lazy("Continent"))
+
+    def validate(self, data):
+        entry = data.get("entry", None)
+        street = data.get("street", None)
+        street_additional = data.get("street_additional", None)
+        zip = data.get("zip", None)
+        geography_city = data.get("geography_city", None)
+
+        if entry and street and street_additional and zip and geography_city:
+            address_contact = AddressContact.objects.filter(
+                street=street, street_additional=street_additional, zip=zip, geography_city=geography_city, entry=entry
+            )
+            if obj := self.instance:
+                address_contact = address_contact.exclude(id=obj.id)
+            if address_contact.exists():
+                raise serializers.ValidationError(
+                    {
+                        "non_field_errors": _("Address already in use for this {type}.").format(
+                            type=entry.entry_type.lower()
+                        )
+                    }
+                )
+        return data
+
+    @wb_serializers.register_resource()
+    def entry_address(self, instance, request, user):
+        if entry := instance.entry:
+            return {
+                "addresses": reverse("wbcore:directory:entry-addresscontact-list", args=[entry.id], request=request),
+            }
+
+        return {}
+
+    class Meta:
+        model = AddressContact
+        fields = (
+            "id",
+            "entry",
+            "_entry",
+            "primary",
+            "location",
+            "street",
+            "street_additional",
+            "zip",
+            "province",
+            "company_contact",
+            "_additional_resources",
+            "geography_city",
+            "_geography_city",
+            "geography_state",
+            "geography_country",
+            "geography_continent",
+        )
+
+
+class TelephoneContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True)
+    _entry = EntryRepresentationSerializer(source="entry")
+    number = wb_serializers.TelephoneField(label=pgettext_lazy("Phonenumber", "Number"))
+
+    def validate(self, data):
+        number = data.get("number", None)
+        entry = data.get("entry", None)
+        formatting_successful = False
+        if number:
+            if entry:
+                telephone_contact = TelephoneContact.objects.filter(number=number, entry=entry)
+                if obj := self.instance:
+                    telephone_contact = telephone_contact.exclude(id=obj.id)
+                if telephone_contact.exists():
+                    raise serializers.ValidationError(
+                        {
+                            "number": _("Phone number already in use for this {type}.").format(
+                                type=entry.entry_type.lower()
+                            )
+                        }
+                    )
+            try:
+                if number.startswith("00"):
+                    number = number.replace("00", "+", 1)
+                parser_number = phonenumbers.parse(
+                    number, global_preferences_registry.manager()["directory__main_country_code"]
+                )
+                if parser_number:
+                    formatted_number = phonenumbers.format_number(parser_number, phonenumbers.PhoneNumberFormat.E164)
+                    formatting_successful = True
+                    data["number"] = formatted_number
+                else:
+                    raise serializers.ValidationError({"number": _("Invalid phone number format")})
+            except Exception as e:
+                raise serializers.ValidationError({"number": _("Invalid phone number format")}) from e
+
+            if entry and formatting_successful:
+                telephone_contact = TelephoneContact.objects.filter(number=formatted_number, entry=entry)
+                if obj := self.instance:
+                    telephone_contact = telephone_contact.exclude(id=obj.id)
+                if telephone_contact.exists():
+                    raise serializers.ValidationError(
+                        {
+                            "number": _("Phone number already in use for this {entry}.").format(
+                                type=entry.entry_type.lower()
+                            )
+                        }
+                    )
+        return data
+
+    class Meta:
+        model = TelephoneContact
+        required_fields = ("entry",)
+        fields = (
+            "id",
+            "company_contact",
+            "entry",
+            "_entry",
+            "location",
+            "number",
+            "primary",
+            "telephone_type",
+            "_additional_resources",
+        )
+
+
+class BankingContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True, default=False)
+    _currency = CurrencyRepresentationSerializer(source="currency")
+    _entry = EntryRepresentationSerializer(source="entry")
+
+    def validate(self, data):
+        iban_repr = data.get("iban", None)
+        swift_bic_repr = data.get("swift_bic", None)
+        entry = data.get("entry", None)
+
+        if iban_repr and iban_repr not in ["", "null"]:
+            try:
+                iban = IBAN(iban_repr)
+                iban_formatted = iban.formatted
+                data["iban"] = iban_formatted
+            except ValueError as e:
+                raise serializers.ValidationError({"iban": e}) from e
+
+            if entry and iban_formatted:
+                banking_contact = BankingContact.objects.filter(iban=iban_formatted, entry=entry)
+                if obj := self.instance:
+                    banking_contact = banking_contact.exclude(id=obj.id)
+                if banking_contact.exists():
+                    raise serializers.ValidationError(
+                        {"iban": _("IBAN already in use for this {type}.").format(type=entry.entry_type.lower())}
+                    )
+
+        if swift_bic_repr and swift_bic_repr not in ["", "null"]:
+            try:
+                BIC(swift_bic_repr)
+            except ValueError as e:
+                raise serializers.ValidationError({"swift_bic": e}) from e
+        return data
+
+    class Meta:
+        model = BankingContact
+        read_only_fields = ("edited",)
+        fields = (
+            "id",
+            "additional_information",
+            "company_contact",
+            "currency",
+            "_currency",
+            "edited",
+            "entry",
+            "_entry",
+            "iban",
+            "institute",
+            "institute_additional",
+            "location",
+            "primary",
+            "status",
+            "swift_bic",
+            "_additional_resources",
+        )
+
+
+class ReadOnlyBankingContactSerializer(BankingContactSerializer):
+    class Meta(BankingContactSerializer.Meta):
+        read_only_fields = BankingContactSerializer.Meta.fields
+
+
+class SocialMediaContactSerializer(wb_serializers.ModelSerializer):
+    company_contact = wb_serializers.BooleanField(read_only=True)
+    _entry = EntryRepresentationSerializer(source="entry")
+
+    def validate(self, data):
+        url = data.get("url", self.instance.url if self.instance else "")
+        try:
+            URLValidator()(url)
+        except ValidationError as e:
+            raise serializers.ValidationError({"url": _("The URL you provided seems to be wrong.")}) from e
+
+        if self.instance and (
+            ((data_entry := data.get("entry")) != self.instance.entry)
+            or ((data_url := data.get("url")) != self.instance.url)
+        ):
+            if SocialMediaContact.objects.filter(entry=data_entry, url=data_url).exists():
+                raise serializers.ValidationError(
+                    {"url": _("This social media account is already in use for this user")}
+                )
+
+        return super().validate(data)
+
+    @wb_serializers.register_resource()
+    def entry_social_media(self, instance, request, user):
+        if entry := instance.entry:
+            return {
+                "social_media": reverse(
+                    "wbcore:directory:entry-socialmediacontact-list", args=[entry.id], request=request
+                ),
+            }
+        return {}
+
+    class Meta:
+        model = SocialMediaContact
+        required_fields = ("entry", "platform", "url")
+        fields = (
+            "id",
+            "company_contact",
+            "entry",
+            "_entry",
+            "platform",
+            "location",
+            "primary",
+            "url",
+            "_additional_resources",
+        )