wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/viewsets/activities.py

@@ -0,0 +1,341 @@
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from django.contrib.messages import info, warning
+from django.db.models import Exists, F, OuterRef, QuerySet, Subquery
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from django.utils.translation import gettext as _
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.agenda.viewsets import CalendarItemViewSet
+from wbcore.contrib.directory.models import (
+    Company,
+    EmailContact,
+    EmployerEmployeeRelationship,
+    Entry,
+    Person,
+    TelephoneContact,
+)
+from wbcore.filters import DjangoFilterBackend
+
+from wbcrm import serializers as crm_serializers
+from wbcrm.filters import (
+    ActivityChartFilter,
+    ActivityFilter,
+    ActivityParticipantFilter,
+    ActivityTypeFilter,
+)
+from wbcrm.models.activities import (
+    Activity,
+    ActivityParticipant,
+    ActivityType,
+    send_invitation_participant_as_task,
+)
+from wbcrm.viewsets.buttons import ActivityButtonConfig, ActivityParticipantButtonConfig
+from wbcrm.viewsets.display import (
+    ActivityDisplay,
+    ActivityParticipantDisplayConfig,
+    ActivityTypeDisplay,
+)
+from wbcrm.viewsets.endpoints import (
+    ActivityEndpointConfig,
+    ActivityParticipantModelEndpointConfig,
+)
+from wbcrm.viewsets.previews.activities import ActivityPreviewConfig
+from wbcrm.viewsets.titles import (
+    ActivityChartModelTitleConfig,
+    ActivityParticipantTitleConfig,
+    ActivityTitleConfig,
+    ActivityTypeTitleConfig,
+)
+
+from ..serializers import (
+    ActivityTypeModelSerializer,
+    ActivityTypeRepresentationSerializer,
+)
+from .recurrence import RecurrenceModelViewSetMixin
+
+
+class ActivityTypeModelViewSet(viewsets.ModelViewSet):
+    IDENTIFIER = "wbcrm:activitytype"
+    LIST_DOCUMENTATION = "wbcrm/markdown/documentation/activitytype.md"
+    queryset = ActivityType.objects.all()
+    serializer_class = ActivityTypeModelSerializer
+    display_config_class = ActivityTypeDisplay
+    title_config_class = ActivityTypeTitleConfig
+    search_fields = ("title",)
+    filterset_class = ActivityTypeFilter
+    ordering = ("title",)
+    ordering_fields = (
+        "title",
+        "color",
+        "score",
+        "icon",
+        "default",
+    )
+
+
+class ActivityTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbcrm:activitytyperepresentation"
+    serializer_class = ActivityTypeRepresentationSerializer
+    queryset = ActivityType.objects.all()
+
+
+class ActivityRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Activity.objects.all()
+    serializer_class = crm_serializers.ActivityRepresentationSerializer
+
+
+class ActivityViewSet(RecurrenceModelViewSetMixin, CalendarItemViewSet):
+    IDENTIFIER = "wbcrm:activity"
+    DEPENDANT_IDENTIFIER = ["wbcrm:calendaritem"]
+    LIST_DOCUMENTATION = "wbcrm/markdown/documentation/activity.md"
+
+    ordering = ["-edited", "id"]
+    search_fields = ("search_vector",)
+    serializer_class = crm_serializers.ActivityModelSerializer
+    display_config_class = ActivityDisplay
+    title_config_class = ActivityTitleConfig
+    filterset_class = ActivityFilter
+    endpoint_config_class = ActivityEndpointConfig
+    preview_config_class = ActivityPreviewConfig
+    button_config_class = ActivityButtonConfig
+    queryset = Activity.objects.all()
+
+    ordering_fields = [
+        "created",
+        "description",
+        "edited",
+        "period",
+        "latest_reviewer__computed_str",
+        "type",
+        "result",
+        "title",
+    ]
+
+    @cached_property
+    def is_external_activity(self):
+        if "pk" in self.kwargs:
+            if activity := self.get_object():
+                return (creator := activity.creator) and not creator.is_internal
+        return False
+
+    @cached_property
+    def is_private_for_user(self):
+        if "pk" in self.kwargs:
+            if activity := self.get_object():
+                return activity.is_private_for_user(self.request.user)
+        return not self.new_mode
+
+    @cached_property
+    def is_confidential_for_user(self):
+        if "pk" in self.kwargs:
+            if activity := self.get_object():
+                return activity.is_confidential_for_user(self.request.user)
+        return not self.new_mode
+
+    @cached_property
+    def participants(self) -> QuerySet[Person]:
+        try:
+            participant_ids = self.request.GET["participants"].split(",")
+        except KeyError:
+            participant_ids = []
+        return Person.objects.filter(id__in=participant_ids)
+
+    @cached_property
+    def companies(self) -> QuerySet[Company]:
+        try:
+            company_ids = self.request.GET["companies"].split(",")
+        except KeyError:
+            company_ids = []
+        return Company.objects.filter(id__in=company_ids)
+
+    @cached_property
+    def entry(self) -> Entry | None:
+        try:
+            return Entry.all_objects.get(id=self.kwargs.get("person_id", self.kwargs["company_id"]))
+        except (KeyError, Entry.DoesNotExist):
+            return self.participants.first() or self.companies.first()
+
+    def get_serializer_class(self):
+        if self.get_action() in ["list", "list-metadata"]:
+            return crm_serializers.ActivityModelListSerializer
+        if (
+            self.is_private_for_user
+            or self.is_confidential_for_user
+            or (
+                "pk" in self.kwargs
+                and (obj := self.get_object())
+                and obj.status in [Activity.Status.CANCELLED, Activity.Status.REVIEWED]
+            )
+        ):
+            return crm_serializers.ReadOnlyActivityModelSerializer
+        return super().get_serializer_class()
+
+    def get_queryset(self):
+        user = self.request.user
+        return (
+            Activity.get_activities_for_user(user, base_qs=super().get_queryset())
+            .select_related("latest_reviewer", "type")
+            .prefetch_related("groups", "participants", "companies", "activity_companies")
+        )
+
+    def add_messages(self, request, instance: Activity | None = None, **kwargs):
+        super().add_messages(request, instance=instance, **kwargs)
+        if instance:
+            if instance.status in [Activity.Status.CANCELLED, Activity.Status.REVIEWED]:
+                info(
+                    self.request,
+                    _(
+                        "You can only modify the review text for an activity that is either cancelled or already reviewed."
+                    ),
+                )
+            if self.is_external_activity:
+                warning(
+                    self.request,
+                    _(
+                        "This activity was created by an external user and synchronized. The modification is restricted."
+                    ),
+                )
+            if warning_message := instance.participants_company_check_message():
+                warning(request, warning_message, extra_tags="auto_close=0")
+
+            # Throws a warning message when there are more people (probably) participating in an activity on-site
+            # than the selected conference room has capacity for.
+            if (
+                instance.conference_room
+                and instance.conference_room.capacity is not None
+                and instance.participants.exclude(
+                    activity_participants__participation_status__in=[
+                        ActivityParticipant.ParticipationStatus.ATTENDS_DIGITALLY,
+                        ActivityParticipant.ParticipationStatus.CANCELLED,
+                    ]
+                ).count()
+                > instance.conference_room.capacity
+            ):
+                warning(
+                    request,
+                    _(
+                        "There are more participants currently participating in this activity than the maximum capacity of the selected conference room allows."
+                    ),
+                )
+
+
+class ActivityChartModelViewSet(viewsets.ChartViewSet):
+    filter_backends = (DjangoFilterBackend,)
+    queryset = Activity.objects.all()
+    filterset_class = ActivityChartFilter
+    IDENTIFIER = "wbcrm:activitychart"
+    title_config_class = ActivityChartModelTitleConfig
+
+    def get_queryset(self):
+        return (
+            Activity.get_activities_for_user(self.request.user)
+            .exclude(period__isnull=True)
+            .filter(visibility=CalendarItem.Visibility.PUBLIC)
+            .annotate(
+                activity_type_color=F("type__color"),
+                activity_type_title=F("type__title"),
+                start_date=F("period__startswith"),
+                end_date=F("period__endswith"),
+            )
+            .select_related("type")
+        )
+
+    def get_plotly(self, queryset):
+        fig = go.Figure()
+        if queryset.exists():
+            df = pd.DataFrame(
+                queryset.values("type", "start_date", "end_date", "activity_type_color", "activity_type_title")
+            )
+            df["start_date"] = df["start_date"].dt.floor("h")
+            df["end_date"] = df["end_date"].dt.ceil("h")
+            df = (
+                pd.concat(
+                    [
+                        pd.DataFrame(index=pd.date_range(r.start_date, r.end_date, freq="1h")).assign(
+                            type=r.type,
+                            activity_type_color=r.activity_type_color,
+                            activity_type_title=r.activity_type_title,
+                        )
+                        for r in df.itertuples()
+                    ]
+                ).reset_index()
+            ).rename(columns={"index": "Period", "activity_type_title": "Type"})
+            df["Period"] = pd.to_datetime(df["Period"])
+            fig = px.histogram(
+                df,
+                x="Period",
+                color="Type",
+                labels="Type",
+                nbins=len(pd.date_range(df["Period"].min(), df["Period"].max(), freq="1h")) + 1,
+            )
+            fig.update_layout(
+                paper_bgcolor="rgba(0,0,0,0)",
+                plot_bgcolor="rgba(0,0,0,0)",
+                title=_("<b>User Activity</b>"),
+                bargap=0.2,
+                autosize=True,
+            )
+
+        return fig
+
+
+class ActivityParticipantModelViewSet(viewsets.ModelViewSet):
+    IDENTIFIER = "wbcrm:activity-participant"
+
+    button_config_class = ActivityParticipantButtonConfig
+    display_config_class = ActivityParticipantDisplayConfig
+    endpoint_config_class = ActivityParticipantModelEndpointConfig
+    filterset_class = ActivityParticipantFilter
+    serializer_class = crm_serializers.ActivityParticipantModelSerializer
+    search_fields = []
+    title_config_class = ActivityParticipantTitleConfig
+    ordering = ["participation_status", "id"]
+    queryset = ActivityParticipant.objects.all()
+
+    def get_queryset(self):
+        activity = get_object_or_404(Activity, id=self.kwargs["activity_id"])
+        return (
+            super()
+            .get_queryset()
+            .filter(activity=activity)
+            .annotate(
+                customer_status=Subquery(
+                    EmployerEmployeeRelationship.objects.filter(
+                        primary=True, employee=OuterRef("participant__pk")
+                    ).values("employer__customer_status__title")[:1]
+                ),
+                position=Subquery(
+                    EmployerEmployeeRelationship.objects.filter(
+                        primary=True, employee=OuterRef("participant__pk")
+                    ).values("position__title")[:1]
+                ),
+                primary_telephone=Subquery(
+                    TelephoneContact.objects.filter(primary=True, entry__id=OuterRef("participant__pk")).values(
+                        "number"
+                    )[:1],
+                ),
+                primary_email=Subquery(
+                    EmailContact.objects.filter(primary=True, entry__id=OuterRef("participant__pk")).values("address")[
+                        :1
+                    ],
+                ),
+                is_occupied=Exists(
+                    Activity.objects.filter(
+                        period__overlap=activity.period,
+                        participants__id=OuterRef("participant__pk"),
+                    )
+                    .exclude(id=activity.id)
+                    .exclude(status=Activity.Status.CANCELLED)
+                ),
+            )
+        )
+
+    @action(methods=["PATCH"], detail=False)
+    def send_external_invitation(self, request, activity_id: int, pk=None):
+        send_invitation_participant_as_task.delay(activity_id)
+        return Response({"__notification": {"title": "Invitation sent to external participants"}})

wbcrm/viewsets/buttons/__init__.py

@@ -0,0 +1,7 @@
+from wbcrm.viewsets.buttons.activities import (
+    ActivityButtonConfig,
+    ActivityParticipantButtonConfig,
+)
+
+from .accounts import AccountButtonConfig
+from .signals import *

wbcrm/viewsets/buttons/accounts.py

@@ -0,0 +1,27 @@
+from django.dispatch import receiver
+from wbcore.contrib.directory.viewsets import (
+    CompanyModelViewSet,
+    EntryModelViewSet,
+    PersonModelViewSet,
+)
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.signals.instance_buttons import add_instance_button
+
+
+class AccountButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {bt.WidgetButton(key="claims", label="Show Claims", icon=WBIcon.TRADE.icon)}
+
+    def get_custom_list_instance_buttons(self):
+        return self.get_custom_instance_buttons()
+
+
+@receiver(add_instance_button, sender=PersonModelViewSet)
+@receiver(add_instance_button, sender=EntryModelViewSet)
+@receiver(add_instance_button, sender=CompanyModelViewSet)
+def crm_adding_instance_buttons(sender, many, *args, **kwargs):
+    if many:
+        return
+    return bt.WidgetButton(key="account", label="Accounts", icon=WBIcon.FOLDERS_MONEY.icon)

wbcrm/viewsets/buttons/activities.py

@@ -0,0 +1,89 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+from wbcrm.models.activities import Activity, ActivityParticipant
+from wbcrm.synchronization.activity.shortcuts import get_backend
+
+DESCRIPTION: str = _(
+    "<p> Are you sure you want to delete all the future instances of this activity? <br> \
+    Only 'Planned' and 'Canceled' activities will be deleted. <br>\
+    Depending on the number of activities to be deleted <br> \
+    it may take some time until the deleted activities are no longer displayed in the activity list. </p>",
+)
+
+
+class ActivityButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self) -> set:
+        if self.view.kwargs.get("pk"):
+            return {
+                bt.WidgetButton(
+                    label=_("Parent Activity"), icon=WBIcon.CALENDAR.icon, key="get_parent_occurrence", weight=110
+                ),
+                bt.ActionButton(
+                    method=RequestType.DELETE,
+                    identifiers=("wbcrm:activity",),
+                    key="delete_next_occurrences",
+                    label=_("Delete Next Occurrences"),
+                    icon=WBIcon.DELETE.icon,
+                    description_fields=DESCRIPTION,
+                    title=_("Delete"),
+                    action_label=_("Delete"),
+                    weight=140,
+                ),
+                bt.WidgetButton(label=_("Next Activity"), icon=WBIcon.NEXT.icon, key="next_occurrence", weight=130),
+                bt.WidgetButton(
+                    label=_("Previous Activity"),
+                    icon=WBIcon.PREVIOUS.icon,
+                    key="previous_occurrence",
+                    weight=120,
+                ),
+            }
+
+        return set()
+
+
+class ActivityParticipantButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set:
+        buttons = set()
+        if not self.view.kwargs.get("pk"):
+            base_url = reverse("wbcrm:activity-list", args=[], request=self.request)
+            activity: Activity = Activity.all_objects.get(id=self.view.kwargs.get("activity_id"))
+            if activity.period:
+                participants_id_set: set[int] = set(activity.participants.values_list("id", flat=True))
+                id_str = ",".join(str(id) for id in participants_id_set)
+
+                start = activity.period.lower.date()
+                end = activity.period.upper.date()
+
+                endpoint = f"{base_url}?participants={id_str}&period={start:%Y-%m-%d},{end:%Y-%m-%d}"
+
+                buttons.add(
+                    bt.WidgetButton(
+                        endpoint=endpoint,
+                        label=_("Show Participants' Activities"),
+                        icon=WBIcon.CALENDAR.icon,
+                    )
+                )
+
+            # Activity sync button to send invitation to external participants
+            if get_backend():
+                if activity.activity_participants.filter(
+                    participation_status=ActivityParticipant.ParticipationStatus.PENDING_INVITATION
+                ).exists():
+                    buttons.add(
+                        bt.ActionButton(
+                            method=RequestType.PATCH,
+                            endpoint=reverse(
+                                "wbcrm:activity-participant-send-external-invitation",
+                                args=[activity.id],
+                                request=self.request,
+                            ),
+                            label="Send invitation to External",
+                            icon=WBIcon.SEND_LATER.icon,
+                        )
+                    )
+        return buttons

wbcrm/viewsets/buttons/signals.py

@@ -0,0 +1,17 @@
+from django.dispatch import receiver
+from django.utils.translation import gettext as _
+from wbcore.contrib.directory.viewsets import (
+    CompanyModelViewSet,
+    EntryModelViewSet,
+    PersonModelViewSet,
+)
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.signals.instance_buttons import add_instance_button
+
+
+@receiver(add_instance_button, sender=PersonModelViewSet)
+@receiver(add_instance_button, sender=EntryModelViewSet)
+@receiver(add_instance_button, sender=CompanyModelViewSet)
+def add_activity_instance_button_in_directory_viewsets(sender, many, *args, **kwargs):
+    return bt.WidgetButton(key="activity", label=_("Activities"), icon=WBIcon.CALENDAR.icon, weight=1)

wbcrm/viewsets/display/__init__.py

@@ -0,0 +1,12 @@
+from .accounts import (
+    AccountDisplayConfig,
+    AccountRoleAccountDisplayConfig,
+    InheritedAccountRoleAccountDisplayConfig,
+)
+from .activities import (
+    ActivityDisplay,
+    ActivityParticipantDisplayConfig,
+    ActivityTypeDisplay,
+)
+from .groups import GroupModelDisplay
+from .products import ProductCompanyRelationshipDisplay, ProductDisplay

wbcrm/viewsets/display/accounts.py

@@ -0,0 +1,110 @@
+from typing import Optional
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class AccountDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title", pinned="left"),
+                dp.Field(key="status", label="Status"),
+                dp.Field(
+                    key="owner",
+                    label="Owner",
+                ),
+                dp.Field(key="reference_id", label="Reference ID"),
+                dp.Field(key="is_terminal_account", label="Terminal Account"),
+                dp.Field(key="is_public", label="Public"),
+                dp.Field(
+                    key="llm",
+                    label="LLM Analysis",
+                    children=[
+                        dp.Field(key="relationship_status", label="Relationship Status"),
+                        dp.Field(key="relationship_summary", label="Relationship Summary", show="open"),
+                        dp.Field(key="action_plan", label="Action Plan", show="open"),
+                    ],
+                ),
+            ],
+            tree=True,
+            tree_group_field="title",
+            tree_group_field_sortable=True,
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_key="parent",
+                    filter_depth=1,
+                    # lookup="id_repr",
+                    filter_blacklist=["parent__isnull"],
+                    list_endpoint=reverse(
+                        "wbcrm:account-list",
+                        args=[],
+                        request=self.request,
+                    ),
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        child_account_section = create_simple_section(
+            "child_account_section", "Child Accounts", [["childaccounts"]], "childaccounts", collapsed=True
+        )
+        account_role_section = create_simple_section(
+            "account_role_section", "Account Roles", [["accountroles"]], "accountroles", collapsed=True
+        )
+        inherited_account_role_section = create_simple_section(
+            "inherited_account_role_section",
+            "Inherited Account Roles",
+            [["inheritedaccountroles"]],
+            "inheritedaccountroles",
+            collapsed=True,
+        )
+        return create_simple_display(
+            [
+                [repeat_field(3, "status")],
+                ["title", "title", "reference_id"],
+                ["is_active", "is_terminal_account", "is_public"],
+                ["parent", "owner", "owner"] if "account_id" not in self.view.kwargs else [repeat_field(3, "owner")],
+                [repeat_field(3, "child_account_section")],
+                [repeat_field(3, "account_role_section")],
+                [repeat_field(3, "inherited_account_role_section")],
+            ],
+            [child_account_section, account_role_section, inherited_account_role_section],
+        )
+
+
+class AccountRoleAccountDisplayConfig(DisplayViewConfig):
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["role_type", "entry"], ["is_hidden", "authorized_hidden_users"]])
+
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="role_type", label="Role"),
+                dp.Field(key="entry", label="entry"),
+                dp.Field(key="is_currently_valid", label="Valid"),
+                dp.Field(key="is_hidden", label="Hidden"),
+                dp.Field(key="authorized_hidden_users", label="Authorized Hidden Users"),
+            ]
+        )
+
+
+class InheritedAccountRoleAccountDisplayConfig(AccountRoleAccountDisplayConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="account", label="Account"),
+                dp.Field(key="role_type", label="Role"),
+                dp.Field(key="entry", label="Entry"),
+                dp.Field(key="is_currently_valid", label="Valid"),
+                dp.Field(key="is_hidden", label="Hidden"),
+                dp.Field(key="authorized_hidden_users", label="Authorized Hidden Users"),
+            ]
+        )