wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/tests/tests.py

@@ -0,0 +1,121 @@
+import pytest
+from django.dispatch import receiver
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from termcolor import colored
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.test import GenerateTest, default_config
+from wbcore.test.mixins import TestViewSet
+from wbcore.test.signals import custom_update_kwargs
+from wbcore.test.utils import get_data_from_factory, get_kwargs, get_or_create_superuser
+
+from wbcrm.factories import AccountFactory
+from wbcrm.viewsets import ActivityParticipantModelViewSet
+from wbcrm.viewsets.accounts import (
+    ChildAccountAccountModelViewSet,
+    InheritedAccountRoleAccountModelViewSet,
+)
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbcrm")
+            and x.__name__
+            not in [
+                "ActivityParticipantModelViewSet",
+                "InheritedAccountRoleAccountModelViewSet",
+                "AccountRoleAccountModelViewSet",
+                "ChildAccountAccountModelViewSet",
+            ],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass
+
+
+# ActivityParticipantModelViewSet Test
+class ActivityParticipantTestViewSet(TestViewSet):
+    def _get_mixins_update_data(self, type):
+        api_request = APIRequestFactory()
+        superuser = get_or_create_superuser()
+        obj = self.factory()
+        data = get_data_from_factory(obj, self.mvs, superuser=superuser, update=True)
+        data["participant"] = PersonFactory().id
+        if type == "PATCH":
+            request = api_request.patch("", data)
+        else:  # "UPDATE"
+            request = api_request.put("", data)
+        request.user = superuser
+        kwargs = get_kwargs(obj, self.mvs, request=request, data=data)
+        return obj, request, kwargs, data
+
+    def test_patch_request(self):
+        obj, request, kwargs, data = self._get_mixins_update_data("PATCH")
+        vs = self.mvs.as_view({"patch": "partial_update"})
+        ep = self._get_endpoint_config(request, kwargs, obj)
+        ep_update = ep.get_instance_endpoint()
+        response = vs(request, **kwargs, data=data)
+        if ep_update:
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data.get("instance"), str(response.data.get("instance")) + " should not be empty"
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
+                str(response.status_code) + f" == 405 ({response.data})"
+            )
+        print(f"- {self.__class__.__name__}:test_patchviewset", colored("PASSED", "green"))  # noqa: T201
+
+    def test_update_request(self):
+        obj, request, kwargs, _ = self._get_mixins_update_data("UPDATE")
+        vs = self.mvs.as_view({"put": "update"})
+        ep = self._get_endpoint_config(request, kwargs, obj)
+        ep_update = ep.get_instance_endpoint()
+        response = vs(request, **kwargs)
+        if ep_update:
+            assert response.status_code == status.HTTP_200_OK, str(response.status_code) + f" == 200 ({response.data})"
+            assert response.data.get("instance"), str(response.data.get("instance")) + " should not be empty"
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED, (
+                str(response.status_code) + f" == 405 ({response.data})"
+            )
+        print(f"- {self.__class__.__name__}:test_update_request", colored("PASSED", "green"))  # noqa: T201
+
+
+class GenerateActivityParticipantTest(GenerateTest):
+    def test_modelviewsets(self, mvs, client):
+        my_test = ActivityParticipantTestViewSet(mvs)
+        my_test.execute_test_list_endpoint(client)
+        my_test.execute_test_detail_endpoint()
+
+
+@pytest.mark.django_db
+@GenerateActivityParticipantTest({"viewsets": [ActivityParticipantModelViewSet]})
+class TestActivityParticipant:
+    pass
+
+
+@receiver(custom_update_kwargs, sender=ChildAccountAccountModelViewSet)
+def receive_kwargs_child_account(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        parent = AccountFactory.create()
+        obj.parent = parent
+        obj.save()
+        return {"account_id": parent.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=InheritedAccountRoleAccountModelViewSet)
+def receive_kwargs_inherited_account_role(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        parent_account = AccountFactory.create()
+        child_account = obj.account
+        child_account.parent = parent_account
+        child_account.save()
+        obj.account = parent_account
+        obj.save()
+        return {"account_id": child_account.id}

wbcrm/typings.py

@@ -0,0 +1,109 @@
+import enum
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.agenda.typings import ConferenceRoom
+from wbcore.contrib.directory.typings import Person
+
+
+@dataclass
+class User:
+    metadata: dict[str, Any]
+    id: str = None
+
+    def __eq__(self, other):
+        if other:
+            return self.id == other.id
+        return super().__eq__(other)
+
+
+@dataclass
+class ParticipantStatus:
+    class ParticipationStatus(enum.Enum):
+        CANCELLED = "CANCELLED"
+        MAYBE = "MAYBE"
+        ATTENDS = "ATTENDS"
+        NOTRESPONDED = "NOTRESPONDED"
+        ATTENDS_DIGITALLY = "ATTENDS_DIGITALLY"
+        PENDING_INVITATION = "PENDING_INVITATION"
+
+    person: Person
+    status_changed: datetime = None
+    status: str = ParticipationStatus.PENDING_INVITATION.name
+    activity: "Activity" = None
+    id: str = None
+
+    def __eq__(self, other):
+        if other and (
+            (self.id and other.id and self.id == other.id)
+            or (self.person == other.person and self.activity == other.activity)
+        ):
+            return True
+        return super().__eq__(other)
+
+
+@dataclass
+class Activity:
+    class ReoccuranceChoice(enum.Enum):
+        NEVER = "NEVER"
+        BUSINESS_DAILY = "RRULE:FREQ=DAILY;INTERVAL=1;WKST=MO;BYDAY=MO,TU,WE,TH,FR"
+        DAILY = "RRULE:FREQ=DAILY"
+        WEEKLY = "RRULE:FREQ=WEEKLY"
+        BIWEEKLY = "RRULE:FREQ=WEEKLY;INTERVAL=2"
+        MONTHLY = "RRULE:FREQ=MONTHLY"
+        QUARTERLY = "RRULE:FREQ=MONTHLY;INTERVAL=3"
+        YEARLY = "RRULE:FREQ=YEARLY"
+
+    class Visibility(enum.Enum):
+        PUBLIC = "PUBLIC"
+        PRIVATE = "PRIVATE"
+        CONFIDENTIAL = "CONFIDENTIAL"
+
+    class ReminderChoice(enum.Enum):
+        NEVER = "NEVER"
+        EVENT_TIME = "EVENT_TIME"
+        MINUTES_5 = "MINUTES_5"
+        MINUTES_15 = "MINUTES_15"
+        MINUTES_30 = "MINUTES_30"
+        HOURS_1 = "HOURS_1"
+        HOURS_2 = "HOURS_2"
+        HOURS_12 = "HOURS_12"
+        WEEKS_1 = "WEEKS_1"
+
+    @property
+    def is_recurrent(self):
+        return self.repeat_choice != self.ReoccuranceChoice.NEVER.name
+
+    metadata: dict[str, Any]
+    title: str
+    period: TimestamptzRange = None
+    description: str = ""
+    participants: list["ParticipantStatus"] = field(default_factory=list)
+    creator: Person = None
+    visibility: str = Visibility.PUBLIC
+    reminder_choice: str = ReminderChoice.MINUTES_15.name
+    is_cancelled: bool = False
+    all_day: bool = False
+    online_meeting: bool = False
+    location: str = None
+    conference_room: ConferenceRoom = None
+    id: str = None
+
+    # parent_occurrence: "Activity" = None
+    recurring_activities: list["Activity"] = field(default_factory=list)
+    invalid_recurring_activities: list["Activity"] = field(default_factory=list)
+    is_root: bool = False
+    is_leaf: bool = False
+    exclude_from_propagation: bool = False
+    propagate_for_all_children: bool = False
+    recurrence_end: datetime = None
+    recurrence_count: int = 0
+    repeat_choice: str = ReoccuranceChoice.NEVER.name
+    delete_notification: bool = False
+
+    def __eq__(self, other):
+        if other and (self.id and other.id and self.id == other.id):
+            return True
+        return super().__eq__(other)

wbcrm/urls.py

@@ -0,0 +1,67 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from . import viewsets
+
+router = WBCoreRouter()
+
+# Representations
+router.register(r"activityrepresentation", viewsets.ActivityRepresentationViewSet, basename="activityrepresentation")
+router.register(r"grouprepresentation", viewsets.GroupRepresentationViewSet, basename="grouprepresentation")
+router.register(r"group", viewsets.GroupModelViewSet, basename="group")
+router.register(r"activitytype", viewsets.ActivityTypeModelViewSet, basename="activitytype")
+router.register(
+    r"activitytyperepresentation", viewsets.ActivityTypeRepresentationViewSet, basename="activitytyperepresentation"
+)
+
+router.register(r"product", viewsets.ProductModelViewSet, basename="product")
+router.register(
+    r"productrepresentation",
+    viewsets.ProductRepresentationViewSet,
+    basename="productrepresentation",
+)
+
+
+# Activity
+router.register(r"activity", viewsets.ActivityViewSet, basename="activity")
+# used to create new activity instances
+
+router.register(r"activitychart", viewsets.ActivityChartModelViewSet, basename="activitychart")
+
+
+activity_router = WBCoreRouter()
+activity_router.register(
+    r"activity-participant",
+    viewsets.ActivityParticipantModelViewSet,
+    basename="activity-participant",
+)
+
+company_router = WBCoreRouter()
+company_router.register(
+    r"company-interestedproduct",
+    viewsets.ProductCompanyRelationshipCompanyModelViewSet,
+    basename="company-interestedproduct",
+)
+
+router.register(r"account", viewsets.AccountModelViewSet, basename="account")
+router.register(r"accountrepresentation", viewsets.AccountRepresentationViewSet, basename="accountrepresentation")
+router.register(
+    r"accountroletyperepresentation",
+    viewsets.AccountRoleTypeRepresentationViewSet,
+    basename="accountroletyperepresentation",
+)
+
+account_router = WBCoreRouter()
+account_router.register(r"childaccount", viewsets.ChildAccountAccountModelViewSet, basename="account-childaccount")
+account_router.register(r"accountrole", viewsets.AccountRoleAccountModelViewSet, basename="account-accountrole")
+account_router.register(
+    r"inheritedrole", viewsets.InheritedAccountRoleAccountModelViewSet, basename="account-inheritedrole"
+)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("activity/<int:activity_id>/", include(activity_router.urls)),
+    path("company/<int:company_id>/", include(company_router.urls)),
+    path("sync/", include(("wbcrm.synchronization.urls", "sync"), namespace="sync")),
+    path("account/<int:account_id>/", include(account_router.urls)),
+]

wbcrm/viewsets/__init__.py

@@ -0,0 +1,22 @@
+from .accounts import (
+    AccountModelViewSet,
+    AccountRepresentationViewSet,
+    AccountRoleAccountModelViewSet,
+    AccountRoleTypeRepresentationViewSet,
+    ChildAccountAccountModelViewSet,
+    InheritedAccountRoleAccountModelViewSet,
+)
+from .activities import (
+    ActivityChartModelViewSet,
+    ActivityParticipantModelViewSet,
+    ActivityRepresentationViewSet,
+    ActivityTypeModelViewSet,
+    ActivityTypeRepresentationViewSet,
+    ActivityViewSet,
+)
+from .groups import GroupModelViewSet, GroupRepresentationViewSet
+from .products import (
+    ProductCompanyRelationshipCompanyModelViewSet,
+    ProductModelViewSet,
+    ProductRepresentationViewSet,
+)

wbcrm/viewsets/accounts.py

@@ -0,0 +1,122 @@
+from django.db.models import Case, Exists, F, IntegerField, OuterRef, When
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from rest_framework.exceptions import AuthenticationFailed
+from wbcore import viewsets
+from wbcore.utils.views import MergeMixin
+
+from wbcrm.filters import AccountFilter, AccountRoleFilterSet
+from wbcrm.models.accounts import Account, AccountRole, AccountRoleType
+from wbcrm.serializers.accounts import (
+    AccountModelSerializer,
+    AccountRepresentationSerializer,
+    AccountRoleModelSerializer,
+    AccountRoleTypeRepresentationSerializer,
+)
+from wbcrm.viewsets.buttons import AccountButtonConfig
+from wbcrm.viewsets.display import (
+    AccountDisplayConfig,
+    AccountRoleAccountDisplayConfig,
+    InheritedAccountRoleAccountDisplayConfig,
+)
+from wbcrm.viewsets.endpoints import (
+    AccountRoleAccountEndpointConfig,
+    ChildAccountAccountEndpointConfig,
+    InheritedAccountRoleAccountEndpointConfig,
+)
+from wbcrm.viewsets.titles import (
+    AccountRoleAccountTitleConfig,
+    AccountTitleConfig,
+    ChildAccountAccountTitleConfig,
+)
+
+from .mixins import AccountPermissionMixin, AccountRolePermissionMixin
+
+
+class AccountRoleTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    ordering_fields = search_fields = ordering = ("title",)
+    serializer_class = AccountRoleTypeRepresentationSerializer
+    queryset = AccountRoleType.objects.all()
+
+
+class AccountRepresentationViewSet(AccountPermissionMixin, viewsets.RepresentationViewSet):
+    ordering_fields = ("title",)
+    search_fields = ["computed_str", "owner__computed_str"]
+    filterset_class = AccountFilter
+
+    serializer_class = AccountRepresentationSerializer
+    queryset = Account.all_objects.all()
+    ordering = ["title"]
+
+
+class AccountModelViewSet(MergeMixin, AccountPermissionMixin, viewsets.ModelViewSet):
+    serializer_class = AccountModelSerializer
+    filterset_class = AccountFilter
+    queryset = Account.all_objects.select_related("owner", "parent").annotate(
+        has_children=Exists(Account.objects.filter(parent=OuterRef("pk"))),
+        _group_key=Case(When(has_children=True, then=F("id")), default=None, output_field=IntegerField()),
+    )
+
+    ordering = ordering_fields = [
+        "title",
+        "owner__computed_str",
+        "reference_id",
+        "is_terminal_account",
+        "is_public",
+        "is_active",
+    ]
+    search_fields = ["computed_str", "owner__computed_str"]
+
+    display_config_class = AccountDisplayConfig
+    title_config_class = AccountTitleConfig
+    button_config_class = AccountButtonConfig
+
+    def get_merged_object_representation_serializer(self):
+        return AccountRepresentationSerializer
+
+
+class ChildAccountAccountModelViewSet(AccountModelViewSet):
+    title_config_class = ChildAccountAccountTitleConfig
+    endpoint_config_class = ChildAccountAccountEndpointConfig
+
+    def dispatch(self, *args, **kwargs):
+        kwargs["parent_id"] = kwargs.get("account_id", None)
+        return super().dispatch(*args, **kwargs)
+
+    def get_queryset(self):
+        return super().get_queryset().filter(parent_id=self.kwargs["account_id"])
+
+
+class AccountRoleAccountModelViewSet(AccountRolePermissionMixin, viewsets.ModelViewSet):
+    display_config_class = AccountRoleAccountDisplayConfig
+    title_config_class = AccountRoleAccountTitleConfig
+    endpoint_config_class = AccountRoleAccountEndpointConfig
+    serializer_class = AccountRoleModelSerializer
+
+    filterset_class = AccountRoleFilterSet
+    queryset = AccountRole.objects.select_related(
+        "entry",
+        "account",
+    )
+    ordering = ["role_type", "id"]
+
+    @cached_property
+    def account(self):
+        account = get_object_or_404(Account, pk=self.kwargs["account_id"])
+        if not account.can_see_account(self.request.user):
+            raise AuthenticationFailed()
+        return account
+
+    def get_queryset(self):
+        return super().get_queryset().filter(account=self.account)
+
+
+class InheritedAccountRoleAccountModelViewSet(AccountRoleAccountModelViewSet):
+    display_config_class = InheritedAccountRoleAccountDisplayConfig
+    endpoint_config_class = InheritedAccountRoleAccountEndpointConfig
+    READ_ONLY = True
+
+    def get_queryset(self):
+        return AccountRole.objects.filter(
+            id__in=self.account.get_inherited_roles_for_account().values("id")
+        ).filter_for_user(self.request.user, validity_date=self.validity_date)