wbcrm 2.2.1__tar.gz

wbcrm-2.2.1/.gitignore

@@ -0,0 +1,181 @@
+~
+
+# Docker volumes
+volumes/
+# Poetry auth file
+auth.toml
+
+media/*
+media/
+mediafiles/
+mediafiles/*
+test/*
+staticfiles/*
+staticfiles/
+#
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+info/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+.dccache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+report.xml
+*/report.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+*.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+.idea/
+.idea.bkp/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+crm/
+# Cython debug symbols
+cython_debug/
+
+# Gitlab Runner
+builds
+builds/
+
+# Integrator Office 365 : reverse proxy tunnel for outlook365
+ngrok
+*/ngrok
+/modules/**/system/
+
+/modules/wbmailing/files/*
+/modules/wbmailing/mailing/*
+
+/projects/*/requirements.txt
+public
+
+# Ignore archive localization generated folder
+backend/modules/**/archive/*
+**/**/requirements.txt
+CHANGELOG-*

wbcrm-2.2.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: wbcrm
+Version: 2.2.1
+Summary: A workbench module that contains all the functionality related to a customer relationship management.
+Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
+Requires-Dist: django-eventtools==1.*
+Requires-Dist: google-api-python-client==2.62.*
+Requires-Dist: google-auth-httplib2==0.1.*
+Requires-Dist: google-auth-oauthlib==0.5.*
+Requires-Dist: wbcore
+Requires-Dist: xlsxwriter==3.*

wbcrm-2.2.1/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "wbcrm"
+description = "A workbench module that contains all the functionality related to a customer relationship management."
+authors = [{ name = "Christopher Wittlinger", email = "c.wittlinger@stainly.com"}]
+dynamic = ["version"]
+
+dependencies = [
+  "wbcore",
+  "django-eventtools == 1.*",
+  "google-api-python-client == 2.62.*",
+  "google-auth-httplib2 == 0.1.*",
+  "google-auth-oauthlib == 0.5.*",
+  "XlsxWriter == 3.*"
+]
+
+[tool.uv.sources]
+wbcore = { workspace = true }
+
+[tool.uv]
+package = true
+
+[tool.hatch.version]
+path = "../../pyproject.toml"
+
+[tool.hatch.build.targets.sdist]
+include = ["wbcrm/*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["wbcrm"]
+only-packages = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

wbcrm-2.2.1/wbcrm/__init__.py

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

wbcrm-2.2.1/wbcrm/admin/__init__.py

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

wbcrm-2.2.1/wbcrm/admin/accounts.py

@@ -0,0 +1,59 @@
+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-2.2.1/wbcrm/admin/activities.py

@@ -0,0 +1,101 @@
+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
+
+
+class ParticipantInline(admin.TabularInline):
+    model = ActivityParticipant
+
+
+class CompanyInline(admin.TabularInline):
+    model = ActivityParticipant
+
+
+@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",)}),
+        (
+            _("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-2.2.1/wbcrm/admin/groups.py

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

wbcrm-2.2.1/wbcrm/admin/products.py

@@ -0,0 +1,8 @@
+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-2.2.1/wbcrm/apps.py

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

wbcrm-2.2.1/wbcrm/configurations/__init__.py

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

wbcrm-2.2.1/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-2.2.1/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-2.2.1/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-2.2.1/wbcrm/factories/accounts.py

@@ -0,0 +1,56 @@
+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-2.2.1/wbcrm/factories/activities.py

@@ -0,0 +1,125 @@
+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
+        global_preferences = global_preferences_registry.manager()
+        assert global_preferences
+        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)