wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/directory/factories/__init__.py

@@ -0,0 +1,34 @@
+from .contacts import (
+    AddressContactFactory,
+    BankingContactFactory,
+    EmailContactFactory,
+    TelephoneContactFactory,
+    WebsiteContactFactory,
+)
+from .entries import (
+    BankCompanyTypeFactory,
+    BankFactory,
+    ClientFactory,
+    CompanyFactory,
+    CompanyTypeFactory,
+    CompanyWithEmployerEmployeeRelationshipFactory,
+    CustomerStatusFactory,
+    EmployersCompanyFactory,
+    EntryFactory,
+    PersonFactory,
+    PersonWithEmployerFactory,
+    Random_ClientFactory,
+    SpecializationFactory,
+    UnemployedPersonFactory,
+    PersonSignatureFactory,
+)
+from .relationships import (
+    ClientManagerRelationshipFactory,
+    EmployerEmployeeRelationshipFactory,
+    ParentRelationshipTypeFactory,
+    PositionFactory,
+    RelationshipFactory,
+    RelationshipTypeFactory,
+    UserIsClientPersonFactory,
+    UserIsManagerEntryFactory,
+)

wbcore/contrib/directory/factories/contacts.py

@@ -0,0 +1,71 @@
+import factory
+
+from ..models import (
+    AddressContact,
+    BankingContact,
+    EmailContact,
+    SocialMediaContact,
+    TelephoneContact,
+    WebsiteContact,
+)
+
+
+class ContactBaseFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        abstract = True
+
+    primary = factory.Faker("pybool")
+    # location = factory.SubFactory('directory.factories.contacts.ContactLocationFactory')
+    entry = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+
+
+class BankingContactFactory(ContactBaseFactory):
+    class Meta:
+        model = BankingContact
+
+    institute = factory.Faker("company")
+    institute_additional = factory.Faker("sentence", nb_words=3)
+    iban = factory.Faker("iban")
+    swift_bic = factory.Faker("swift")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    additional_information = factory.Faker("paragraph")
+
+
+class AddressContactFactory(ContactBaseFactory):
+    class Meta:
+        model = AddressContact
+
+    street = factory.Faker("street_address")
+    street_additional = factory.Faker("sentence", nb_words=3)
+    zip = factory.Faker("zipcode")
+    geography_city = factory.SubFactory("wbcore.contrib.geography.factories.CityFactory")
+
+
+class TelephoneContactFactory(ContactBaseFactory):
+    class Meta:
+        model = TelephoneContact
+
+    number = factory.Faker("phone_number")
+    # telephone_type = factory.SubFactory('directory.factories.contacts.ContactTelephoneTypeFactory')
+
+
+class EmailContactFactory(ContactBaseFactory):
+    class Meta:
+        model = EmailContact
+
+    address = factory.Faker("email")
+
+
+class WebsiteContactFactory(ContactBaseFactory):
+    class Meta:
+        model = WebsiteContact
+
+    url = factory.Faker("uri")
+
+
+class SocialMediaContactFactory(ContactBaseFactory):
+    class Meta:
+        model = SocialMediaContact
+
+    platform = factory.Iterator(SocialMediaContact.Platforms)
+    url = factory.Faker("url")

wbcore/contrib/directory/factories/entries.py

@@ -0,0 +1,169 @@
+import random
+
+import factory
+from django.core.files.base import ContentFile
+from django.db.models import signals
+
+from ..models import Company, CompanyType, CustomerStatus, Entry, Person, Specialization
+
+
+class CustomerStatusFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+
+    class Meta:
+        model = CustomerStatus
+
+
+class CompanyTypeFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+
+    class Meta:
+        model = CompanyType
+        django_get_or_create = ["title"]
+
+
+class BankCompanyTypeFactory(CompanyTypeFactory):
+    title = "Bank"
+
+
+class SpecializationFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+
+    class Meta:
+        model = Specialization
+
+
+@factory.django.mute_signals(signals.pre_save, signals.post_save)
+class EntryBaseFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        abstract = False
+
+
+class EntryContactBaseFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        abstract = False
+
+    profile_image = factory.django.ImageField(filename="image_profile.jpeg")
+
+    banking = factory.RelatedFactory("wbcore.contrib.directory.factories.contacts.BankingContactFactory", "entry")
+    addresses = factory.RelatedFactory("wbcore.contrib.directory.factories.contacts.WebsiteContactFactory", "entry")
+
+
+class EntryFactory(EntryBaseFactory):
+    class Meta:
+        model = Entry
+
+    # entry_type
+    signature = factory.django.ImageField(filename="signature.jpeg")
+    activity_heat = random.uniform(0.0, 1.0)
+    salutation = factory.Faker("text", max_nb_chars=64)
+
+    @factory.post_generation
+    def relationship_managers(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for in_charg in extracted:
+                self.relationship_managers.add(in_charg)
+
+
+class CompanyFactory(EntryFactory):
+    class Meta:
+        model = Company
+
+    name = factory.Faker("company")
+    customer_status = factory.SubFactory(CustomerStatusFactory)
+    type = factory.SubFactory(CompanyTypeFactory)
+    tier = factory.Iterator(Company.Tiering.choices, getter=lambda tier: tier[0])
+
+
+class EntryContactFactory(EntryFactory):
+    @factory.post_generation
+    def telephones(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for telephone in extracted:
+                self.telephones.add(telephone)
+
+    @factory.post_generation
+    def emails(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for email in extracted:
+                self.emails.add(email)
+
+
+class EmployersCompanyFactory(CompanyFactory):
+    @factory.post_generation
+    def employees(self, create, extracted, **kwargs):
+        if extracted:
+            for _ in range(extracted):
+                PersonFactory(employers=(self,))
+
+
+class BankFactory(CompanyFactory):
+    type = factory.SubFactory(BankCompanyTypeFactory)
+
+
+class PersonFactory(EntryFactory):
+    class Meta:
+        model = Person
+
+    first_name = factory.Faker("first_name")
+    last_name = factory.Faker("last_name")
+    birthday = factory.Faker("date_object")
+    personality_profile_red = random.randint(1, 5)
+    personality_profile_green = random.randint(1, 5)
+    personality_profile_blue = random.randint(1, 5)
+    prefix = factory.Iterator(Person.Prefix.choices, getter=lambda prefix: prefix[0])
+
+    @factory.post_generation
+    def employers(self, create, extracted, **kwargs):
+        if extracted:
+            for employer in extracted:
+                self.employers.add(employer)
+
+
+class PersonWithEmployerFactory(PersonFactory):
+    employers = factory.RelatedFactory(
+        "wbcore.contrib.directory.factories.relationships.EmployerEmployeeRelationshipFactory",
+        factory_related_name="employee",
+    )
+
+
+class PersonSignatureFactory(PersonFactory):
+    signature = factory.LazyAttribute(
+        lambda _: ContentFile(factory.django.ImageField()._make_data({"width": 1024, "height": 768}), "example.jpg")
+    )
+
+
+class CompanyWithEmployerEmployeeRelationshipFactory(CompanyFactory):
+    employees = factory.RelatedFactory(
+        "wbcore.contrib.directory.factories.relationships.EmployerEmployeeRelationshipFactory",
+        factory_related_name="employer",
+    )
+
+
+class ClientFactory(PersonFactory):
+    @factory.post_generation
+    def clients(self, create, extracted, **kwargs):
+        if extracted:
+            for person in extracted:
+                self.clients.add(person)
+
+
+class Random_ClientFactory(ClientFactory):
+    @factory.post_generation
+    def clients(self, create, extracted, **kwargs):
+        self.clients.add(PersonFactory())
+
+
+class UnemployedPersonFactory(PersonFactory):
+    @factory.post_generation
+    def employers(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            self.employers.set()

wbcore/contrib/directory/factories/relationships.py

@@ -0,0 +1,77 @@
+import factory
+import pytz
+
+from ..models import (
+    ClientManagerRelationship,
+    EmployerEmployeeRelationship,
+    Position,
+    Relationship,
+    RelationshipType,
+)
+from .entries import CompanyFactory, EntryFactory, PersonFactory
+
+
+class PositionFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+
+    class Meta:
+        model = Position
+
+
+class RelationshipTypeFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = RelationshipType
+
+    title = factory.Sequence(lambda n: f"Title {n}")
+    counter_relationship = factory.SubFactory(
+        "wbcore.contrib.directory.factories.ParentRelationshipTypeFactory", counter_relationship=None
+    )
+
+
+class ParentRelationshipTypeFactory(RelationshipTypeFactory):
+    counter_relationship = None
+
+
+class RelationshipFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Relationship
+
+    relationship_type = factory.SubFactory(
+        "wbcore.contrib.directory.factories.RelationshipTypeFactory",
+    )
+    from_entry = factory.SubFactory(EntryFactory)
+    to_entry = factory.SubFactory(EntryFactory)
+
+
+class EmployerEmployeeRelationshipFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = EmployerEmployeeRelationship
+
+    employer = factory.SubFactory(CompanyFactory)
+    employee = factory.SubFactory(PersonFactory)
+    position = factory.SubFactory(PositionFactory)
+    position_name = factory.Faker("text", max_nb_chars=64)
+    primary = False
+
+
+class ClientManagerRelationshipFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ClientManagerRelationship
+
+    status = ClientManagerRelationship.Status.APPROVED
+    client = factory.SubFactory(EntryFactory)
+    relationship_manager = factory.SubFactory(PersonFactory)
+    created = factory.Faker("date_time", tzinfo=pytz.utc)
+    primary = False
+
+
+class UserIsClientPersonFactory(PersonFactory):
+    @factory.post_generation
+    def relationships(self, create, extracted, **kwargs):
+        ClientManagerRelationshipFactory(relationship_manager=self)
+
+
+class UserIsManagerEntryFactory(EntryFactory):
+    @factory.post_generation
+    def relationships(self, create, extracted, **kwargs):
+        ClientManagerRelationshipFactory(client=self)

wbcore/contrib/directory/filters/__init__.py

@@ -0,0 +1,22 @@
+from .contacts import (
+    AddressContactCompanyFilter,
+    AddressContactPersonFilter,
+    BankingContactCompanyFilter,
+    BankingContactFilter,
+    BankingContactPersonFilter,
+    EmailContactCompanyFilter,
+    EmailContactPersonFilter,
+    SocialMediaContactCompanyFilter,
+    SocialMediaContactPersonFilter,
+    TelephoneContactCompanyFilter,
+    TelephoneContactPersonFilter,
+    WebsiteContactCompanyFilter,
+    WebsiteContactPersonFilter,
+)
+from .entries import CompanyFilter, EntryFilter, PersonFilter, UserIsManagerFilter
+from .relationships import (
+    ClientManagerFilter,
+    RelationshipEntryFilter,
+    RelationshipFilter,
+    RelationshipTypeFilter,
+)

wbcore/contrib/directory/filters/contacts.py

@@ -0,0 +1,233 @@
+import django_filters
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters as wb_filters
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.geography.models import Geography
+
+from ..models import (
+    AddressContact,
+    BankingContact,
+    ContactLocationChoices,
+    ContactTelephoneChoices,
+    EmailContact,
+    Entry,
+    SocialMediaContact,
+    TelephoneContact,
+    WebsiteContact,
+)
+
+
+class ContactPersonFilter(wb_filters.FilterSet):
+    company_contact = wb_filters.BooleanFilter(
+        label=_("Company Contact"),
+        method="boolean_is_company_contact",
+    )
+
+    def boolean_is_company_contact(self, queryset, name, value):
+        if value is None:
+            return queryset
+        return queryset.filter(company_contact=value)
+
+
+class EmailContactCompanyFilter(wb_filters.FilterSet):
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"), choices=ContactLocationChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+
+    class Meta:
+        model = EmailContact
+        fields = {
+            "primary": ["exact"],
+            "address": ["exact", "icontains"],
+        }
+
+
+class EmailContactPersonFilter(EmailContactCompanyFilter, ContactPersonFilter):
+    pass
+
+
+class AddressContactCompanyFilter(wb_filters.FilterSet):
+    geography_city = wb_filters.ModelChoiceFilter(
+        label=_("City"),
+        queryset=Geography.cities.all(),
+        endpoint=Geography.get_representation_endpoint(),
+        value_key=Geography.get_representation_value_key(),
+        label_key=Geography.get_representation_label_key(),
+        method="filter_city",
+        filter_params={"level": 3},
+    )
+
+    geography_country = wb_filters.ModelChoiceFilter(
+        label=_("Country"),
+        queryset=Geography.countries.all(),
+        endpoint=Geography.get_representation_endpoint(),
+        value_key=Geography.get_representation_value_key(),
+        label_key=Geography.get_representation_label_key(),
+        method="filter_country",
+        filter_params={"level": 1},
+    )
+
+    geography_state = wb_filters.ModelChoiceFilter(
+        label=_("State"),
+        queryset=Geography.states.all(),
+        endpoint=Geography.get_representation_endpoint(),
+        value_key=Geography.get_representation_value_key(),
+        label_key=Geography.get_representation_label_key(),
+        method="filter_state",
+        filter_params={"level": 2},
+    )
+
+    geography_continent = wb_filters.ModelChoiceFilter(
+        label=_("Continent"),
+        queryset=Geography.continents.all(),
+        endpoint=Geography.get_representation_endpoint(),
+        value_key=Geography.get_representation_value_key(),
+        label_key=Geography.get_representation_label_key(),
+        method="filter_continent",
+        filter_params={"level": 0},
+    )
+
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"), choices=ContactLocationChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+
+    def filter_city(self, queryset, name, value):
+        if value:
+            return queryset.filter(geography_city=value)
+        return queryset
+
+    def filter_country(self, queryset, name, value):
+        if value:
+            return queryset.filter(geography_city__parent__parent=value)
+        return queryset
+
+    def filter_state(self, queryset, name, value):
+        if value:
+            return queryset.filter(geography_city__parent=value)
+        return queryset
+
+    def filter_continent(self, queryset, name, value):
+        if value:
+            return queryset.filter(geography_city__parent__parent__parent=value)
+        return queryset
+
+    class Meta:
+        model = AddressContact
+        fields = {
+            "street": ["exact", "icontains"],
+            "street_additional": ["exact", "icontains"],
+            "zip": ["exact", "icontains"],
+            "primary": ["exact"],
+        }
+
+
+class AddressContactPersonFilter(AddressContactCompanyFilter, ContactPersonFilter):
+    pass
+
+
+class TelephoneContactCompanyFilter(wb_filters.FilterSet):
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"), choices=ContactLocationChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+    telephone_type = wb_filters.MultipleChoiceFilter(
+        label=_("Types"), choices=ContactTelephoneChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+
+    class Meta:
+        model = TelephoneContact
+        fields = {
+            "number": ["exact", "icontains"],
+            "primary": ["exact"],
+        }
+
+
+class TelephoneContactPersonFilter(TelephoneContactCompanyFilter, ContactPersonFilter):
+    pass
+
+
+class WebsiteContactCompanyFilter(wb_filters.FilterSet):
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"), choices=ContactLocationChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+
+    class Meta:
+        model = WebsiteContact
+        fields = {
+            "url": ["exact", "icontains"],
+            "primary": ["exact"],
+        }
+
+
+class WebsiteContactPersonFilter(WebsiteContactCompanyFilter, ContactPersonFilter):
+    pass
+
+
+class BankingContactCompanyFilter(wb_filters.FilterSet):
+    currency = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Currencies"),
+        queryset=Currency.objects.all(),
+        endpoint=Currency.get_representation_endpoint(),
+        value_key=Currency.get_representation_value_key(),
+        label_key=Currency.get_representation_label_key(),
+    )
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"), choices=ContactLocationChoices.choices, widget=django_filters.widgets.CSVWidget
+    )
+    edited__lte = wb_filters.DateTimeFilter(
+        label=_("Edited"),
+        lookup_expr="lte",
+        field_name="edited",
+    )
+
+    edited__gte = wb_filters.DateTimeFilter(
+        label=_("Edited"),
+        lookup_expr="gte",
+        field_name="edited",
+    )
+
+    class Meta:
+        model = BankingContact
+        fields = {
+            "status": ["exact"],
+            "institute": ["exact", "icontains"],
+            "institute_additional": ["exact", "icontains"],
+            "iban": ["exact", "icontains"],
+            "swift_bic": ["exact", "icontains"],
+            "primary": ["exact"],
+            "additional_information": ["exact", "icontains"],
+        }
+
+
+class BankingContactPersonFilter(BankingContactCompanyFilter, ContactPersonFilter):
+    pass
+
+
+class BankingContactFilter(BankingContactCompanyFilter):
+    entry = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Entries"),
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+    )
+
+
+class SocialMediaContactCompanyFilter(wb_filters.FilterSet):
+    location = wb_filters.MultipleChoiceFilter(
+        label=_("Locations"),
+        choices=ContactLocationChoices.choices,
+        widget=django_filters.widgets.CSVWidget,
+    )
+    platform = wb_filters.MultipleChoiceFilter(
+        label=_("Social Media Platform"),
+        choices=SocialMediaContact.Platforms.choices,
+        widget=django_filters.widgets.CSVWidget,
+    )
+
+    class Meta:
+        model = SocialMediaContact
+        fields = {"url": ["exact", "icontains"], "primary": ["exact"]}
+
+
+class SocialMediaContactPersonFilter(SocialMediaContactCompanyFilter, ContactPersonFilter):
+    pass