wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbcrm/admin/__init__.py

@@ -0,0 +1,5 @@
+from .accounts import AccountRoleModelAdmin, AccountModelAdmin
+from .activities import ActivityAdmin, ActivityTypeAdmin
+from .groups import GroupModelAdmin
+from .products import ProductAdmin
+from .events import EventModelAdmin

wbcrm/admin/accounts.py

@@ -0,0 +1,60 @@
+from django.contrib import admin
+from mptt.admin import MPTTModelAdmin
+
+from wbcrm.models.accounts import (
+    Account,
+    AccountRole,
+    AccountRoleType,
+    AccountRoleValidity,
+)
+
+
+class AccountRoleValidityTabularInline(admin.TabularInline):
+    model = AccountRoleValidity
+    fields = ("timespan",)
+    extra = 0
+
+
+class AccountRoleTabularInline(admin.TabularInline):
+    model = AccountRole
+    fields = ("role_type", "entry", "weighting", "is_hidden")
+    autocomplete_fields = ["entry", "account"]
+    extra = 0
+    show_change_link = True
+
+
+class AccountTabularInline(admin.TabularInline):
+    model = Account
+    fields = ("title", "status", "owner", "is_terminal_account", "is_active", "is_public")
+    autocomplete_fields = ["owner", "parent"]
+    fk_name = "parent"
+    show_change_link = True
+    extra = 0
+
+
+@admin.register(AccountRoleType)
+class AccountRoleTypeModelAdmin(admin.ModelAdmin):
+    list_display = ("title", "key")
+    search_fields = ("title", "key")
+
+
+@admin.register(AccountRole)
+class AccountRoleModelAdmin(admin.ModelAdmin):
+    list_display = ("role_type", "entry", "account", "is_hidden")
+    inlines = [AccountRoleValidityTabularInline]
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).select_related("entry", "account")
+
+
+@admin.register(Account)
+class AccountModelAdmin(MPTTModelAdmin):
+    mptt_level_indent = 20
+    fsm_field = ["status"]
+    search_fields = ["title"]
+    list_display = ["computed_str", "status", "is_active", "is_terminal_account", "is_public", "owner"]
+    inlines = [AccountRoleTabularInline, AccountTabularInline]
+    autocomplete_fields = ["owner", "parent"]
+
+    def get_queryset(self, request):
+        return Account.all_objects.select_related("owner", "parent")

wbcrm/admin/activities.py

@@ -0,0 +1,104 @@
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+from reversion.admin import VersionAdmin
+
+from wbcrm.models import Activity, ActivityParticipant, ActivityType
+from wbcrm.models.activities import ActivityCompanyThroughModel
+
+
+class ParticipantInline(admin.TabularInline):
+    model = ActivityParticipant
+
+
+class CompanyInline(admin.TabularInline):
+    model = ActivityCompanyThroughModel
+
+
+@admin.register(ActivityType)
+class ActivityTypeAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "title")
+
+
+class ActivityInline(admin.StackedInline):
+    model = Activity
+    fk_name = "parent_occurrence"
+    extra = 0
+    fieldsets = (
+        (
+            _("Main information"),
+            {
+                "fields": (
+                    "title",
+                    "description",
+                )
+            },
+        ),
+    )
+
+
+@admin.register(Activity)
+class ActivityAdmin(VersionAdmin):
+    search_fields = ("title",)
+    list_display = ("id", "status", "title", "period", "is_active", "parent_occurrence_id", "metadata")
+    fieldsets = (
+        (_("Main information"), {"fields": ("title", "description", "result", "creator")}),
+        (_("Meta"), {"fields": ("status", "type", "visibility", "is_active", "metadata")}),
+        (_("Temporal Information"), {"fields": ("period", "all_day")}),
+        (_("Geographical Information"), {"fields": ("location", "location_longitude", "location_latitude")}),
+        (_("Linked Entries"), {"fields": ("assigned_to", "groups")}),
+        (_("Linked Activities"), {"fields": ("preceded_by",)}),
+        (_("LLM"), {"fields": ("heat", "summary")}),
+        (
+            _("Recurrence"),
+            {
+                "fields": (
+                    "repeat_choice",
+                    "parent_occurrence",
+                    ("recurrence_count", "recurrence_end"),
+                    "propagate_for_all_children",
+                )
+            },
+        ),
+    )
+
+    raw_id_fields = (
+        "assigned_to",
+        "participants",
+        "groups",
+        "preceded_by",
+        "creator",
+        "latest_reviewer",
+        "parent_occurrence",
+    )
+
+    inlines = [ActivityInline, ParticipantInline, CompanyInline]
+
+    def reversion_register(self, model, **options):
+        options = {
+            "exclude": (
+                "created",
+                "creator",
+                "edited",
+            ),
+        }
+        super().reversion_register(model, **options)
+
+    def get_queryset(self, request):
+        return Activity.all_objects.all()
+
+
+@admin.register(ActivityParticipant)
+class ActivityParticipantAdmin(VersionAdmin):
+    search_fields = ("activity", "participant")
+    list_display = ("id", "activity", "participant", "participation_status")
+
+    def reversion_register(self, model, **options):
+        options = {
+            "follow": (
+                "activity",
+                "participant",
+                "participation_status",
+            )
+        }
+        super().reversion_register(model, **options)

wbcrm/admin/events.py

@@ -0,0 +1,43 @@
+from django.contrib import admin
+
+from wbcrm.models.events import Event
+
+
+@admin.register(Event)
+class EventModelAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "resource",
+        "change_type",
+        "subject",
+        "resource_uuid",
+        "action_type",
+        "action",
+        "created",
+        "updated",
+    )
+    search_fields = ("data", "result")
+
+    @staticmethod
+    def change_type(obj):
+        return obj.data.get("change_type", "")
+
+    @staticmethod
+    def resource(obj):
+        return obj.data.get("resource", "")
+
+    @staticmethod
+    def subject(obj):
+        return obj.data.get("subject", "")
+
+    @staticmethod
+    def resource_uuid(obj):
+        return obj.data.get("uid", "")
+
+    @staticmethod
+    def action_type(obj):
+        return obj.result.get("action_type", "")
+
+    @staticmethod
+    def action(obj):
+        return obj.result.get("action", "")

wbcrm/admin/groups.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+
+from wbcrm.models import Group
+
+
+@admin.register(Group)
+class GroupModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ("members",)

wbcrm/admin/products.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+
+from wbcrm.models import Product
+
+
+@admin.register(Product)
+class ProductAdmin(admin.ModelAdmin):
+    search_fields = ("title",)
+    list_display = ("title", "id")

wbcrm/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WbcrmConfig(AppConfig):
+    name = "wbcrm"

wbcrm/configurations/__init__.py

@@ -0,0 +1 @@
+from .base import CRMDevBaseConfiguration, CRMProductionBaseConfiguration

wbcrm/configurations/base.py

@@ -0,0 +1,16 @@
+from configurations import values
+from wbcore.configurations import DevBaseConfiguration, ProductionBaseConfiguration
+
+
+class CRMDevBaseConfiguration(DevBaseConfiguration):
+    SECRET_KEY = values.Value("THIS-IS-NOT-A-SECRET-KEY", environ_prefix=None)
+    DEBUG = values.BooleanValue(True, environ_prefix=None)
+    DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
+    DISABLE_NOTIFICATION = values.BooleanValue(False, environ_prefix=None)
+    DEV_USER = values.Value(None, environ_prefix=None)
+    ADD_REVERSION_ADMIN = True
+    DEFAULT_CREATE_ENDPOINT_BASENAME = values.Value("wbcrm:activity-list", environ_prefix=None)
+
+
+class CRMProductionBaseConfiguration(ProductionBaseConfiguration):
+    pass

wbcrm/dynamic_preferences_registry.py

@@ -0,0 +1,38 @@
+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 BooleanPreference, IntegerPreference
+
+general = Section("wbcrm")
+
+
+@global_preferences_registry.register
+class CheckForMandatoryParticipants(BooleanPreference):
+    section = general
+    name = "mandatory_participants"
+    default = True
+
+    verbose_name = _("Check for mandatory participants")
+    help_text = _(
+        'Determines whether or not companies must be entered as participants in the "Companies" field for activities.'
+    )
+
+
+@global_preferences_registry.register
+class RecurrenceActivityEndDate(IntegerPreference):
+    section = general
+    name = "recurrence_maximum_allowed_days"
+    # this short default value, is just for the moment to test the process and until we know how to handle the recurring activities more efficient
+    default = 10 * 365
+
+    verbose_name = _("The default Maximum allowed days")
+
+
+@global_preferences_registry.register
+class RecurrenceActivityDateListLength(IntegerPreference):
+    section = general
+    name = "recurrence_maximum_count"
+    # this short default value, is just for the moment to test the process and until we know how to handle the recurring activities more efficient
+    default = 366
+
+    # verbose_name = _("For each date in the date list we create a child activity.number at which the date list will be cut.")

wbcrm/factories/__init__.py

@@ -0,0 +1,14 @@
+# from wbcore.contrib.currency.tests import factories
+
+from .accounts import AccountFactory, AccountRoleFactory, AccountRoleTypeFactory, AccountWithOwnerFactory
+from .activities import (
+    ActivityCompanyFactory,
+    ActivityFactory,
+    ActivityParticipantFactory,
+    ActivityPersonFactory,
+    ActivityTypeCALLFactory,
+    ActivityTypeFactory,
+    RecurringActivityFactory,
+)
+from .groups import GroupFactory
+from .products import ProductFactory

wbcrm/factories/accounts.py

@@ -0,0 +1,57 @@
+import factory
+from slugify import slugify
+
+from wbcrm.models.accounts import Account, AccountRole, AccountRoleType
+
+
+class AccountFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("company")
+    status = Account.Status.OPEN
+    # owner =
+    is_public = True
+    is_active = True
+    is_terminal_account = True
+
+    class Meta:
+        model = Account
+
+
+class AccountWithOwnerFactory(AccountFactory):
+    owner = factory.SubFactory("wbcore.contrib.directory.factories.entries.EntryFactory")
+
+
+class AccountRoleTypeFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("word")
+    key = factory.LazyAttribute(lambda o: slugify(o.title))
+
+    class Meta:
+        model = AccountRoleType
+        django_get_or_create = ["key"]
+
+
+class AccountRoleFactory(factory.django.DjangoModelFactory):
+    role_type = factory.SubFactory("wbcrm.factories.AccountRoleTypeFactory")
+    entry = factory.SubFactory("wbcore.contrib.directory.factories.entries.EntryFactory")
+    account = factory.SubFactory("wbcrm.factories.AccountFactory", parent=None)
+    is_hidden = False
+
+    @factory.post_generation
+    def authorized_hidden_users(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for user in extracted:
+                self.authorized_hidden_users.add(user)
+
+    @factory.post_generation
+    def visibility_daterange(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            v = self.validity_set.first()
+            v.timespan = extracted
+            v.save()
+
+    class Meta:
+        model = AccountRole

wbcrm/factories/activities.py

@@ -0,0 +1,124 @@
+import datetime
+import random
+
+import factory
+import pytz
+from dynamic_preferences.registries import global_preferences_registry
+from faker import Faker
+from wbcore.contrib.authentication.factories import InternalUserFactory
+from wbcore.contrib.directory.factories import CompanyFactory, PersonFactory
+
+from wbcrm.models.activities import Activity, ActivityParticipant, ActivityType
+
+fake = Faker()
+
+
+class ActivityTypeFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+    color = factory.Faker("color")
+    score = factory.Iterator([ActivityType.Score.HIGH, ActivityType.Score.MEDIUM, ActivityType.Score.LOW])
+
+    class Meta:
+        model = ActivityType
+        django_get_or_create = ("title",)
+
+
+class ActivityTypeCALLFactory(ActivityTypeFactory):
+    title = "Call"
+
+
+class ActivityFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Activity
+
+    title = factory.Faker("text", max_nb_chars=64)
+    description = factory.Faker("paragraph", nb_sentences=5)
+    start = factory.LazyAttribute(lambda _: fake.date_time(tzinfo=pytz.utc))
+    end = factory.LazyAttribute(
+        lambda _self: _self.start + datetime.timedelta(days=fake.pyint(0, 100), hours=fake.pyint(1, 23))
+    )
+    disable_participant_check = True
+    location = factory.Faker("local_latlng")
+    location_longitude = factory.Faker("longitude")
+    location_latitude = factory.Faker("latitude")
+    created = factory.Faker("date_time", tzinfo=pytz.utc)
+    creator = factory.LazyAttribute(lambda _: InternalUserFactory.create().profile)
+    latest_reviewer = factory.SubFactory(PersonFactory)
+    reviewed_at = factory.Faker("date_time", tzinfo=pytz.utc)
+    edited = factory.Faker("date_time", tzinfo=pytz.utc)
+    assigned_to = factory.SubFactory(PersonFactory)
+    preceded_by = None
+    parent_occurrence = None
+    propagate_for_all_children = False
+    recurrence_end = None
+    recurrence_count = None
+    repeat_choice = Activity.ReoccuranceChoice.NEVER
+    type = factory.SubFactory(ActivityTypeFactory)
+    item_type = "wbcrm.Activity"
+
+    @factory.post_generation
+    def participants(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for participant in extracted:
+                self.participants.add(participant)
+
+    @factory.post_generation
+    def companies(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for company in extracted:
+                self.companies.add(company)
+
+    @factory.post_generation
+    def groups(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for group in extracted:
+                self.groups.add(group)
+
+    @factory.post_generation
+    def entities(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for entity in extracted:
+                self.entities.add(entity)
+
+
+class RecurringActivityFactory(ActivityFactory):
+    repeat_choice = random.choice(list(filter(lambda x: x != "NEVER", Activity.ReoccuranceChoice.names)))
+    recurrence_count = 3
+
+
+class ActivityCompanyFactory(ActivityFactory):
+    @factory.post_generation
+    def companies(self, create, extracted, **kwargs):
+        # Create company
+        company = CompanyFactory()
+        # Set global config main_company=company.id
+        global_preferences_registry.manager()["directory__main_company"] = company.id
+        self.companies.add(company)
+
+
+class ActivityPersonFactory(ActivityFactory):
+    @factory.post_generation
+    def participants(self, create, extracted, **kwargs):
+        # Create person
+        person = PersonFactory()
+        self.participants.add(person)
+
+
+class ActivityParticipantFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ActivityParticipant
+
+    participant = factory.SubFactory(PersonFactory)
+    activity = factory.SubFactory(ActivityFactory)

wbcrm/factories/groups.py

@@ -0,0 +1,24 @@
+import random
+
+import factory
+from wbcore.contrib.directory.factories import EntryFactory
+
+from wbcrm.models.groups import Group
+
+
+class GroupFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Group
+
+    title = factory.Faker("text", max_nb_chars=64)
+
+    @factory.post_generation
+    def members(self, create, extracted, **kwargs):
+        if not create:
+            return
+        elif extracted:
+            for member in extracted:
+                self.members.add(member)
+        else:
+            for _ in range(1, random.randrange(2, 10)):
+                self.members.add(EntryFactory())

wbcrm/factories/products.py

@@ -0,0 +1,11 @@
+import factory
+
+from wbcrm.models import Product
+
+
+class ProductFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("text", max_nb_chars=32)
+    is_competitor = factory.Faker("pybool")
+
+    class Meta:
+        model = Product

wbcrm/filters/__init__.py

@@ -0,0 +1,10 @@
+from .accounts import AccountFilter, AccountRoleFilterSet
+from .activities import (
+    ActivityChartFilter,
+    ActivityFilter,
+    ActivityParticipantFilter,
+    ActivityTypeFilter,
+)
+from .groups import GroupFilter
+from .products import ProductCompanyFilterSet, ProductFilterSet
+from .signals import *

wbcrm/filters/accounts.py

@@ -0,0 +1,80 @@
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import Entry
+
+from wbcrm.models.accounts import Account, AccountRole
+
+
+class AccountFilter(wb_filters.FilterSet):
+    parent = wb_filters.ModelChoiceFilter(
+        label="Parent",
+        queryset=Account.objects.all(),
+        endpoint=Account.get_representation_endpoint(),
+        value_key=Account.get_representation_value_key(),
+        label_key=Account.get_representation_label_key(),
+        hidden=True,
+    )
+    parent__isnull = wb_filters.BooleanFilter(field_name="parent", lookup_expr="isnull", hidden=True)
+    customer = wb_filters.ModelChoiceFilter(
+        label="Customer",
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+        method="filter_customer",
+    )
+
+    owner = wb_filters.ModelMultipleChoiceFilter(
+        label="Owner",
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+    )
+
+    not_owner = wb_filters.ModelMultipleChoiceFilter(
+        column_field_name="owner",
+        lookup_icon="!=",
+        lookup_label="Not Equals",
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+        method="filter_not_owner",
+    )
+
+    status = wb_filters.MultipleChoiceFilter(
+        choices=Account.Status.choices, label="Status", initial=[Account.Status.OPEN.value]
+    )
+
+    def filter_not_owner(self, queryset, name, value):
+        if value:
+            return queryset.exclude(owner__in=value)
+        return queryset
+
+    def filter_customer(self, queryset, name, value):
+        if value:
+            return queryset.filter(id__in=Account.get_accounts_for_customer(value))
+        return queryset
+
+    class Meta:
+        model = Account
+        fields = {
+            "reference_id": ["icontains"],
+            "is_active": ["exact"],
+            "parent": ["exact", "isnull"],
+            "is_terminal_account": ["exact"],
+            "is_public": ["exact"],
+        }
+
+
+class AccountRoleFilterSet(wb_filters.FilterSet):
+    is_currently_valid = wb_filters.BooleanFilter(label="Valid", initial=True, field_name="is_currently_valid")
+
+    class Meta:
+        model = AccountRole
+        fields = {
+            "role_type": ["exact"],
+            "entry": ["exact"],
+            "is_hidden": ["exact"],
+            "authorized_hidden_users": ["exact"],
+        }