wbcrm 2.2.4__py2.py3-none-any.whl → 2.2.5__py2.py3-none-any.whl

wbcrm/kpi_handlers/activities.py

@@ -0,0 +1,171 @@
+from typing import Type
+
+from django.db.models import Q
+from django.db.models.expressions import F
+from django.db.models.query import QuerySet
+from django.utils.translation import gettext_lazy as _
+from wbcore import serializers
+from wbcore.contrib.directory.models import Person
+from wbcore.serializers.serializers import Serializer
+from wbcrm.models import Activity, ActivityParticipant, ActivityType
+from wbcrm.serializers import ActivityTypeRepresentationSerializer
+from wbhuman_resources.models.kpi import KPI, KPIHandler
+from wbhuman_resources.serializers import KPIModelSerializer
+
+
+class NumberOfActivityKPISerializer(KPIModelSerializer):
+    activity_type = serializers.PrimaryKeyRelatedField(
+        required=True, many=True, queryset=ActivityType.objects.all(), label=_("Activity Type")
+    )
+    _activity_type = ActivityTypeRepresentationSerializer(source="activity_type", many=True)
+
+    activity_area = serializers.ChoiceField(
+        default="all",
+        choices=[("only_internal", _("Only Internal")), ("only_external", _("Only External")), ("all", _("All"))],
+    )
+    person_participates = serializers.BooleanField(
+        default=True,
+        label=_("Participants of Activity"),
+        help_text=_("Activities considered are related to the participants"),
+    )
+    person_created = serializers.BooleanField(
+        default=True, label=_("Creator of activity"), help_text=_("Activities considered are related to the creator")
+    )
+    person_assigned = serializers.BooleanField(
+        default=True,
+        label=_("Person Assigned"),
+        help_text=_("Activities considered are related to the persons assigned"),
+    )
+
+    def update(self, instance, validated_data):
+        activity_type = validated_data.get(
+            "activity_type",
+            instance.additional_data["serializer_data"].get(
+                "activity_type", list(ActivityType.objects.values_list("id", flat=True))
+            ),
+        )
+        activity_area = validated_data.get(
+            "activity_area",
+            instance.additional_data["serializer_data"].get("activity_area", "all"),
+        )
+
+        person_participates = validated_data.get(
+            "person_participates",
+            instance.additional_data["serializer_data"].get("person_participates", True),
+        )
+        person_created = validated_data.get(
+            "person_created",
+            instance.additional_data["serializer_data"].get("person_created", True),
+        )
+        person_assigned = validated_data.get(
+            "person_assigned",
+            instance.additional_data["serializer_data"].get("person_assigned", True),
+        )
+
+        additional_data = instance.additional_data
+        additional_data["serializer_data"]["activity_type"] = (
+            [_type.id for _type in validated_data.get("activity_type")]
+            if validated_data.get("activity_type")
+            else activity_type
+        )
+        additional_data["serializer_data"]["activity_area"] = activity_area
+        additional_data["serializer_data"]["person_participates"] = person_participates
+        additional_data["serializer_data"]["person_created"] = person_created
+        additional_data["serializer_data"]["person_assigned"] = person_assigned
+
+        additional_data["list_data"] = instance.get_handler().get_list_data(additional_data["serializer_data"])
+        validated_data["additional_data"] = additional_data
+
+        return super().update(instance, validated_data)
+
+    class Meta(KPIModelSerializer.Meta):
+        fields = (
+            *KPIModelSerializer.Meta.fields,
+            "activity_type",
+            "_activity_type",
+            "activity_area",
+            "person_participates",
+            "person_created",
+            "person_assigned",
+        )
+
+
+class NumberOfActivityKPI(KPIHandler):
+    def get_name(self) -> str:
+        return _("Number of Activities")
+
+    def get_serializer(self) -> Type[Serializer]:
+        return NumberOfActivityKPISerializer
+
+    def annotate_parameters(self, queryset: QuerySet[KPI]) -> QuerySet[KPI]:
+        return queryset.annotate(
+            activity_type=F("additional_data__serializer_data__activity_type"),
+            activity_area=F("additional_data__serializer_data__activity_area"),
+            person_participates=F("additional_data__serializer_data__person_participates"),
+            person_created=F("additional_data__serializer_data__person_created"),
+            person_assigned=F("additional_data__serializer_data__person_assigned"),
+        )
+
+    def get_list_data(self, serializer_data: dict) -> list[str]:
+        activity_types = list(
+            ActivityType.objects.filter(pk__in=serializer_data["activity_type"]).values_list("title", flat=True)
+        )
+        return [
+            _("Activity Type: {types}").format(types=activity_types),
+            _("Activity Area: {area}").format(area=serializer_data["activity_area"]),
+            _("Person Participates: {participating}").format(participating={serializer_data["person_participates"]}),
+            _("Person Created: {created}").format(created=serializer_data["person_created"]),
+            _("Person Assigned: {assigned}").format(assigned=serializer_data["person_assigned"]),
+        ]
+
+    def get_display_grid(self) -> list[list[str]]:
+        return [
+            ["activity_type"] * 3,
+            ["activity_area"] * 3,
+            ["person_created", "person_assigned", "person_participates"],
+        ]
+
+    def evaluate(self, kpi: "KPI", evaluated_person=None, evaluation_date=None) -> int:
+        persons = (
+            [evaluated_person.id] if evaluated_person else kpi.evaluated_persons.all().values_list("id", flat=True)
+        )
+        serializer_data = kpi.additional_data.get("serializer_data")
+        qs = Activity.objects.filter(
+            period__startswith__date__gte=kpi.period.lower,
+            period__endswith__date__lte=evaluation_date if evaluation_date else kpi.period.upper,
+        ).exclude(status=Activity.Status.CANCELLED)
+        qs = (
+            qs.filter(type__id__in=serializer_data.get("activity_type"))
+            if serializer_data.get("activity_type")
+            else qs
+        )
+
+        condition = None
+        if serializer_data.get("person_created") or serializer_data.get("person_created") is None:
+            condition = Q(creator__in=persons)
+        if serializer_data.get("person_assigned") or serializer_data.get("person_assigned") is None:
+            condition = (condition | Q(assigned_to__in=persons)) if condition else Q(assigned_to__in=persons)
+        if serializer_data.get("person_participates") or serializer_data.get("person_participates") is None:
+            condition = (condition | Q(participants__in=persons)) if condition else Q(participants__in=persons)
+        if condition:
+            qs = qs.filter(condition)
+
+        if (activity_area := serializer_data.get("activity_area")) and (activity_area != "all"):
+            participant_ids = set(
+                ActivityParticipant.objects.filter(activity__id__in=qs.values_list("id", flat=True)).values_list(
+                    "participant", flat=True
+                )
+            )
+            employee_ids = Person.objects.filter_only_internal().values_list("id", flat=True)
+            externals = set(
+                Person.objects.filter(Q(id__in=participant_ids) & ~Q(id__in=employee_ids)).values_list("id", flat=True)
+            )
+            if activity_area == "only_internal":
+                qs = qs.exclude(
+                    Q(creator__in=externals) | Q(assigned_to__in=externals) | Q(participants__id__in=externals)
+                )
+            elif activity_area == "only_external":
+                qs = qs.filter(
+                    Q(creator__in=externals) | Q(assigned_to__in=externals) | Q(participants__id__in=externals)
+                )
+        return qs.distinct("id").count()

wbcrm/models/llm/activity_summaries.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from pydantic import BaseModel, Field
+from wbcore.contrib.ai.llm.config import LLMConfig
+
+if TYPE_CHECKING:
+    from wbcrm.models import Activity
+
+
+def analyze_activity_prompt(activity: "Activity"):
+    return [
+        SystemMessage(
+            content="You are a manager in a company and there are activities, both internal as well as external, meaning between service providers, clients and ourselves. We want to analyze these activities in regards of their sentiment and summarize them in English. The summary should be a very short bottom-line focussed text."
+        ),
+        HumanMessage(
+            content=f"title={activity.title}, description={activity.description}, period={activity.period}, participants={activity.participants.all()}, companies={activity.companies.all()}, review={activity.result}"
+        ),
+    ]
+
+
+class ActivityLLMResponseModel(BaseModel):
+    heat: int = Field(..., ge=1, le=4, description="The sentiment heat.")
+    summary: str = Field(..., description="A summary of the activity in English.")
+
+
+analyze_activity = LLMConfig["Activity"](
+    key="analyze",
+    prompt=analyze_activity_prompt,
+    on_save=True,
+    on_condition=lambda instance: instance.status == "REVIEWED",
+    output_model=ActivityLLMResponseModel,
+)

wbcrm/models/llm/analyze_relationship.py

@@ -0,0 +1,54 @@
+from typing import TYPE_CHECKING
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from pydantic import BaseModel, Field
+from wbcore.contrib.ai.llm.config import LLMConfig
+from wbcrm.models.activities import Activity
+
+if TYPE_CHECKING:
+    from wbcrm.models import Account
+
+
+def analyze_relationship_prompt(account: "Account"):
+    messages = [
+        SystemMessage(
+            content="Based on the recent interactions/activities, current relationship health, and planned actions with the customer, provide a status score (1 to 5, where 1 is cold and 5 is hot), a summary of the relationship, and recommended next steps for maintaining or improving the relationship. Keep in mind that more information might become available later to refine these insights. Please include all information that is relevant to the relationship in the summary. Regarding the activities/interactions, older interactions are less relevant than recent ones."
+        ),
+        HumanMessage(
+            content=f"The title of the account: {account.title}",
+        ),
+    ]
+    if account.owner:
+        for activity in Activity.objects.filter(companies__id__in=[account.owner.id], status="REVIEWED"):
+            messages.append(
+                HumanMessage(
+                    content=f"Activity: {activity.summary}, with sentiment: {activity.heat}, period: {activity.period}",
+                )
+            )
+
+    return messages
+
+
+class AccountRelationshipResponseModel(BaseModel):
+    relationship_status: int = Field(
+        ...,
+        ge=1,
+        le=5,
+        description="Rate the customer relationship status from 1 to 5. 1 being the cold and 5 being the hot.",
+    )
+    relationship_summary: str = Field(
+        ...,
+        description="Briefly summarize the current state of the relationship and recent interactions. Also include any additional information that might be relevant.",
+    )
+    action_plan: str = Field(
+        ..., description="Provide the next recommended actions or steps to engage with the customer."
+    )
+
+
+analyze_relationship = LLMConfig["Account"](
+    key="analyze_relationship",
+    prompt=analyze_relationship_prompt,
+    on_save=True,
+    on_condition=lambda act: (act.status == act.Status.OPEN) and act.owner is not None and act.is_root_node(),
+    output_model=AccountRelationshipResponseModel,
+)

wbcrm/report/activity_report.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+from io import BytesIO
+
+import xlsxwriter
+from celery import shared_task
+from django.conf import settings
+from django.core.mail import EmailMultiAlternatives
+from django.db.models import Q
+from django.template.loader import get_template
+from django.utils import timezone
+from django.utils.html import strip_tags
+from django.utils.translation import gettext as _
+from wbcore.contrib.directory.models import Person
+from wbcrm.models import Activity, ActivityType
+from xlsxwriter.utility import xl_rowcol_to_cell
+
+
+def set_cell(worksheet, row, col, value, width_cols, base_format):
+    cell = xl_rowcol_to_cell(row, col)
+    if value:
+        worksheet.write_string(cell, value, base_format)
+        if len(value) > width_cols[col]:
+            width_cols[col] = len(value)
+
+
+@shared_task
+def create_report_and_send(profile_id, employee_id, start_date=None, end_date=None):
+    employee = Person.objects.get(id=employee_id)
+    profile = Person.objects.get(id=profile_id)
+    if end_date is None:
+        end_date = timezone.now()
+    if start_date is None:
+        start_date = datetime(year=end_date.year, month=1, day=1, hour=0, minute=0, second=0)
+
+    report = create_report(employee_id, start_date, end_date)
+
+    html = get_template("email/activity_report.html")
+
+    context = {"profile": profile, "employee": employee}
+    html_content = html.render(context)
+
+    msg = EmailMultiAlternatives(
+        _("Report"), strip_tags(html_content), settings.DEFAULT_FROM_EMAIL, [profile.user_account.email]
+    )
+    msg.attach_alternative(html_content, "text/html")
+    title = _("all")
+    if start_date and end_date:
+        title = "{}_{}".format(start_date.strftime("%m/%d/%Y-%H:%M:%S"), end_date.strftime("%m/%d/%Y-%H:%M:%S"))
+    msg.attach(
+        "report_{}_{}.xlsx".format(employee.computed_str, title),
+        report.read(),
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+    msg.send()
+
+
+def create_report(employee, start_date, end_date):
+    output = BytesIO()
+    workbook = xlsxwriter.Workbook(output, {"in_memory": True})
+
+    base_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10})
+    bold_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10, "bold": True})
+    related_activities = Activity.objects.filter(
+        Q(participants__id=employee) | Q(creator__id=employee) | Q(assigned_to__id=employee)
+    )
+    activities = Activity.get_inrange_activities(related_activities, start_date, end_date)
+    # HERE STARTS THE FIRST WORKSHEET
+    for type in ActivityType.objects.all():
+        width_cols = [5, 5, 16, 8, 7, 11, 12]
+        activities_type = activities.filter(type=type.id)
+        worksheet = workbook.add_worksheet(type.title)
+        worksheet.write_string(0, 0, _("Title"), bold_format)
+        worksheet.write_string(0, 1, _("Start"), bold_format)
+        worksheet.write_string(0, 2, _("Duration (hours)"), bold_format)
+        worksheet.write_string(0, 3, _("Location"), bold_format)
+        worksheet.write_string(0, 4, _("Creator"), bold_format)
+        worksheet.write_string(0, 5, _("Assigned to"), bold_format)
+        worksheet.write_string(0, 6, _("Participants"), bold_format)
+
+        worksheet.write_string(2, 0, _("Total"), bold_format)
+        worksheet.write_string(2, 1, str(len(activities_type.all())), bold_format)
+
+        for row, activity in enumerate(activities_type.all(), start=4):
+            hours = (activity.period.upper - activity.period.lower).total_seconds() / 3600
+            duration = format(hours, ".2f")
+            creator = activity.creator
+            creator_name = ""
+            if creator:
+                creator_name = creator.computed_str
+            assigned_to = activity.assigned_to
+            assigned_to_name = ""
+            if assigned_to:
+                assigned_to_name = assigned_to.computed_str
+            participants = ", ".join([participant.computed_str for participant in activity.participants.all()])
+
+            set_cell(worksheet, row, 0, activity.title, width_cols, base_format)
+            set_cell(worksheet, row, 1, f"{activity.period.lower:%d.%m.%Y}", width_cols, base_format)
+            set_cell(worksheet, row, 2, duration, width_cols, base_format)
+            set_cell(worksheet, row, 2, activity.location, width_cols, base_format)
+            set_cell(worksheet, row, 4, creator_name, width_cols, base_format)
+            set_cell(worksheet, row, 5, assigned_to_name, width_cols, base_format)
+            set_cell(worksheet, row, 6, participants, width_cols, base_format)
+
+        for col, max_width in enumerate(width_cols):
+            if max_width > 300:
+                max_width = 300
+            worksheet.set_column(col, col, max_width)
+    workbook.close()
+    output.seek(0)
+    return output

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/create.py

@@ -0,0 +1,75 @@
+from datetime import timedelta
+
+from celery import shared_task
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.authentication.models import User
+from wbcrm.models import Activity
+
+from ...typing_informations import GoogleEventType
+from ...utils import GoogleSyncUtils
+from .update import update_activity_participant
+
+
+@shared_task(queue="synchronization")
+def create_internal_activity_based_on_google_event(
+    event: GoogleEventType, user: User, service: Resource, parent_occurrence: Activity | None = None, is_instance=False
+):
+    """
+    A method for creating a "Workbench" activity based on a "Google" event. If the google event is a recurring event, this method will also create the corresponding workbench activities.
+
+    :param event:           A google event body.
+    :param user:            The current workbench user.
+    :param service:         Thee google Resource.
+    :param parent_occurrence: The parent activity. This is only used when the activity is part of a recurring chain. Per default it is None.
+    :param is_instance:     True, when the event is a google instance (A instance is an event that is part of a recurring chain)
+    """
+
+    external_id = event["id"]
+    if event.get("status") == "cancelled" or Activity.objects.filter(external_id=event["id"]).exists():
+        return
+
+    event_creator = event.get("organizer", {})
+    event_creator_mail = event_creator.get("email", "")
+    event_creator_displayed_name = event_creator.get("displayName", "")
+    creator = GoogleSyncUtils.get_or_create_person(event_creator_mail, event_creator_displayed_name)
+    event_start, event_end = GoogleSyncUtils.get_start_and_end(event)
+    if event_start == event_end:
+        event_end = event_end + timedelta(seconds=1)
+    period = TimestamptzRange(event_start, event_end)  # type: ignore
+    all_day: bool = True if event["start"].get("date") else False
+    metadata = {"google_backend": {"instance": event}} if is_instance else {"google_backend": {"event": event}}
+
+    act = Activity.objects.create(
+        external_id=external_id,
+        title=event.get("summary", "(No Subject)"),
+        assigned_to=creator,
+        creator=creator,
+        description=event.get("description", ""),
+        start=event_start,
+        end=event_end,
+        period=period,
+        all_day=all_day,
+        location=event.get("location"),
+        visibility=GoogleSyncUtils.convert_event_visibility_to_activity_visibility(event.get("visibility", "")),
+        metadata=metadata,
+        parent_occurrence=parent_occurrence,
+    )
+
+    update_activity_participant(event, act)
+
+    if event.get("recurrence") and not is_instance:
+        instances: dict = service.events().instances(calendarId=user.email, eventId=event["id"]).execute()
+        instance_items: list[GoogleEventType] = instances["items"]
+        global_preferences = global_preferences_registry.manager()
+        max_list_length: int = global_preferences["wbcrm__recurrence_maximum_count"]
+        instance_items = instance_items[:max_list_length]
+
+        for item in instance_items:
+            if item["start"] == act.metadata["google_backend"].get("event", {}).get("start"):
+                updated_metadata: dict = act.metadata
+                updated_metadata["google_backend"] |= {"instance": item}
+                Activity.objects.filter(id=act.id).update(metadata=updated_metadata)
+            else:
+                create_internal_activity_based_on_google_event(item, user, service, act, True)

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/delete.py

@@ -0,0 +1,78 @@
+from django.db.models import QuerySet
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from wbcrm.models import Activity
+
+
+def cancel_or_delete_activity(activity: "Activity") -> None:
+    # Activity is cancelled rather than disable if global preference is True
+    if global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"]:
+        Activity.objects.filter(id=activity.id).update(status=Activity.Status.CANCELLED)
+    else:
+        activity.delete()
+
+
+def cancel_or_delete_activity_queryset(activity_qs: QuerySet["Activity"]) -> None:
+    # Activities are cancelled rather than delete if global preference is True
+    if global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"]:
+        activity_qs.update(status=Activity.Status.CANCELLED)
+    else:
+        activity_qs.delete()
+
+
+def delete_single_activity(activity: Activity):
+    """
+    Deletes the activity that has the corresponding external ID
+    """
+    Activity.objects.filter(id=activity.id).update(external_id=None)
+    cancel_or_delete_activity(activity)
+
+
+def delete_recurring_activity(activity: Activity, event: dict, user_mail: str, service: Resource):
+    """
+    Handles the deletion of recurring activities (either a single activity, a certain number of activities or all activities),
+    based on the changes done to the google event.
+
+    :param event:           The google event dict that was deleted.
+    :param activity:        The corresponding workbench activity.
+    :param user_mail:       The e-mail address of the current user.
+    :param service:         The google service to interact with googles resources.
+    """
+
+    parent_occurrence = activity.parent_occurrence if activity.parent_occurrence else activity
+    metadata_event = parent_occurrence.metadata["google_backend"].get(
+        "event", parent_occurrence.metadata["google_backend"].get("instance", {})
+    )
+    if event.get("recurringEventId"):
+        # Delete single event in event chain
+        if activity.status not in [Activity.Status.REVIEWED, Activity.Status.FINISHED]:
+            cancel_or_delete_activity(activity)
+
+    elif event.get("recurrence") != metadata_event.get("recurrence"):
+        # Delete all events after a certain event in the event chain
+
+        event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+        external_id_list: list = [instance["id"] for instance in event_instances["items"]]
+        activities_to_remove = Activity.objects.filter(
+            metadata__google_backend__instance__recurringEventId__startswith=event["id"],
+            status=Activity.Status.PLANNED,
+        ).exclude(metadata__google_backend__instance__id__in=external_id_list)
+        first_in_list = activities_to_remove.order_by("start").first()
+        metadata = parent_occurrence.metadata
+        metadata["google_backend"] |= {"event": event}
+        Activity.objects.filter(id=parent_occurrence.id).update(metadata=metadata)
+        if (
+            first_in_list
+            and first_in_list.id == parent_occurrence.id
+            and parent_occurrence.status not in [Activity.Status.REVIEWED, Activity.Status.FINISHED]
+        ):
+            cancel_or_delete_activity(parent_occurrence)
+        cancel_or_delete_activity_queryset(activities_to_remove)
+
+    else:
+        # Delete all events in event chain
+        activities_to_cancel = Activity.objects.filter(
+            parent_occurrence=parent_occurrence, status=Activity.Status.PLANNED
+        )
+        cancel_or_delete_activity_queryset(activities_to_cancel)
+        cancel_or_delete_activity(activity)

wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/update.py

@@ -0,0 +1,155 @@
+from datetime import timedelta
+
+from django.utils import timezone
+from dynamic_preferences.registries import global_preferences_registry
+from googleapiclient.discovery import Resource
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.directory.models import Person
+from wbcrm.models import Activity, ActivityParticipant
+
+from ...typing_informations import GoogleEventType
+from ...utils import GoogleSyncUtils
+
+
+def update_activity_participant(event: GoogleEventType, activity: Activity):
+    """
+    Used to update the participants in a workbench activity.
+
+    :param event:   The Google event dict with the participant informations.
+    :param activity:The corresponding activity.
+    """
+
+    can_sync_external_participants: bool = global_preferences_registry.manager()[
+        "wbactivity_sync__sync_external_participants"
+    ]
+    event_participants = GoogleSyncUtils.get_or_create_participants(event, activity.creator)
+
+    def update_or_add_participants():
+        for event_participant in event_participants:
+            if person := Person.objects.filter(id=event_participant["person_id"]).first():
+                activity.participants.add(person.id)
+                ActivityParticipant.objects.filter(activity=activity, participant=person).update(
+                    participation_status=event_participant["status"]
+                )
+
+    if can_sync_external_participants or not activity.creator.is_internal:  # type: ignore
+        update_or_add_participants()
+    else:
+        internal_activity_participants_set = set(
+            activity.participants.filter(id__in=Person.objects.filter_only_internal())
+        )
+        event_participants_set = set(Person.objects.filter(id__in=[x["person_id"] for x in event_participants]))
+        missing_activity_participants = internal_activity_participants_set - event_participants_set
+        update_or_add_participants()
+        if missing_activity_participants:
+            ActivityParticipant.objects.filter(
+                participant__in=missing_activity_participants, activity=activity
+            ).update(participation_status=ActivityParticipant.ParticipationStatus.CANCELLED)
+
+
+def update_single_activity(event: GoogleEventType, activity: Activity, change_status=False):
+    """
+    Updates a single workbench activity based on changes done in a google event.
+
+    :param event:           The google event dict that was updated.
+    :param activity:        The corresponding workbench activity.
+    :param change_status:   Information wheter the status of the event was updated or not.
+    """
+    if activity.external_id is None:
+        return
+    if activity.status == Activity.Status.REVIEWED or activity.status == Activity.Status.FINISHED:
+        metadata = activity.metadata
+        metadata["google_backend"] |= {"event": event} if not event.get("recurringEventId") else {"instance": event}
+        Activity.objects.filter(id=activity.id).update(
+            external_id=event["id"] if "_" in activity.external_id else activity.external_id,
+            metadata=metadata,
+        )
+        return
+    event_organizer = event.get("organizer", {})
+    event_organizer_mail = event_organizer.get("email", "")
+    event_organizer_displayed_name = event_organizer.get("displayName", "")
+    organizer = GoogleSyncUtils.get_or_create_person(event_organizer_mail, event_organizer_displayed_name)
+    event_start, event_end = GoogleSyncUtils.get_start_and_end(event)
+    if event_start == event_end:
+        event_end = event_end + timedelta(seconds=1)
+    period = TimestamptzRange(event_start, event_end)  # type: ignore
+    all_day: bool = True if event["start"].get("date") else False
+
+    metadata = activity.metadata
+    metadata["google_backend"] |= {"event": event} if not event.get("recurringEventId") else {"instance": event}
+    Activity.objects.filter(id=activity.id).update(
+        title=event.get("summary", "(No Subject)"),
+        assigned_to=organizer,
+        description=event.get("description", ""),
+        start=event_start,
+        status=Activity.Status.PLANNED if change_status else activity.status,
+        end=event_end,
+        period=period,
+        all_day=all_day,
+        location=event.get("location"),
+        visibility=GoogleSyncUtils.convert_event_visibility_to_activity_visibility(event.get("visibility")),
+        metadata=metadata,
+        external_id=event["id"] if "_" in activity.external_id else activity.external_id,
+    )
+    update_activity_participant(event, activity)
+
+
+def update_all_activities(activity: Activity, event: GoogleEventType, user_mail: str, service: Resource):
+    """
+    Updates all workbench activities in a recurrence chain based on changes done in a google event.
+
+    :param event:       The google event dict that was updated.
+    :param activity:    The corresponding workbench activity.
+    :param user_mail:   The e-mail address of the current user.
+    :param service:     The google service to interact with googles resources.
+    """
+
+    activity_instance = activity.metadata["google_backend"].get(
+        "instance", activity.metadata["google_backend"].get("event", {})
+    )
+    event_start, event_end = event["start"], event["end"]
+    activity_start, activity_end = activity_instance.get("start"), activity_instance.get("end")
+    event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+    instance_items = event_instances["items"]
+    connected_activities = Activity.objects.filter(parent_occurrence=activity)
+    connected_activities |= Activity.objects.filter(metadata__google_backend__instance__recurringEventId=event["id"])
+    connected_activities |= Activity.objects.filter(id=activity.id)
+    if event_start != activity_start or event_end != activity_end:
+        # If the start/end time of the google event chain changes, google will also change the id of the event instances. That is why we need to handle this case seperatly
+        connected_activities = connected_activities.order_by("external_id")
+        activity_list = list(connected_activities)
+        instance_items.sort(key=lambda x: x["start"].get("date", x["start"]["dateTime"]))
+        for instance in instance_items:
+            if len(activity_list) == 0:
+                break
+            activity_instance = activity_list.pop(0)
+            update_single_activity(instance, activity_instance)
+            activity_instance.refresh_from_db()
+    else:
+        for instance in instance_items:
+            if activity_child := connected_activities.filter(external_id=instance["id"]).first() or (
+                activity_child := Activity.objects.filter(
+                    metadata__google_backend__instance__id=instance["id"]
+                ).first()
+            ):
+                update_single_activity(instance, activity_child)
+
+
+def update_activities_from_new_parent(event: dict, parent_occurrence: Activity, user_mail: str, service: Resource):
+    """
+    This methods updates child activities whose parent activity was altered.
+
+    :param event:           The google event dict that was updated.
+    :param parent_occurrence: The corresponding workbench parent activity.
+    :param user_mail:       The e-mail address of the current user.
+    :param service:         The google service to interact with googles resources.
+
+    """
+    now = timezone.now()
+    canceled_child_activities = Activity.objects.filter(
+        parent_occurrence=parent_occurrence, period__startswith__gt=now
+    )
+    event_instances: dict = service.events().instances(calendarId=user_mail, eventId=event["id"]).execute()
+    for instance in event_instances["items"]:
+        if activity := canceled_child_activities.filter(external_id=instance["id"]).first():
+            update_single_activity(instance, activity, True)

wbcrm/synchronization/activity/backends/google/request_utils/internal_to_external/update.py

@@ -0,0 +1,180 @@
+import re
+import warnings
+from uuid import uuid4
+
+from dateutil.rrule import rrule, rrulestr
+from googleapiclient.discovery import Resource
+from wbcrm.models import Activity
+
+from ...utils import GoogleSyncUtils
+
+
+def update_single_event(creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict):
+    """
+    Updates a single Google-Event.
+
+    After the external event has been updated, the metadata field of the internal activity is also updated with the information of the external event.
+
+    Note: Do not use for recurring events.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+
+    updated_external_event = (
+        google_service.events()
+        .update(calendarId=creator_mail, eventId=internal_activity.external_id, body=updates)
+        .execute()
+    )
+    metadata = internal_activity.metadata | {"google_backend": {"event": updated_external_event}}
+    Activity.objects.filter(id=internal_activity.id).update(metadata=metadata)
+
+
+def update_single_recurring_event(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates a single recurring Google-Event.
+
+    After the external event has been updated, the metadata field of the internal activity is also updated with the information of the external event.
+
+    Note: Do not use for not recurring events.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+    is_parent = Activity.objects.filter(parent_occurrence=internal_activity).exists()
+    external_id = (
+        internal_activity.metadata["google_backend"]["instance"].get("id")
+        if is_parent
+        else internal_activity.external_id
+    )
+    updated_event = google_service.events().patch(calendarId=creator_mail, eventId=external_id, body=updates).execute()
+    metadata = internal_activity.metadata
+    metadata["google_backend"] |= {"instance": updated_event}
+    Activity.objects.filter(id=internal_activity.id).update(metadata=metadata)
+
+
+def update_all_recurring_events_from_parent(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates all Google-Event-Instances belonging to the same recurring event chain.
+
+    After the external event instances have been updated, the metadata fields of the internal activities is also updated with the information of the corresponding external event instance.
+
+    Note: Do not use when creating a new parent activity from an existing child.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench parent activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+    updated_event = (
+        google_service.events()
+        .patch(calendarId=creator_mail, eventId=internal_activity.external_id, body=updates)
+        .execute()
+    )
+    metadata = internal_activity.metadata | {"google_backend": {"event": updated_event}}
+    instances = google_service.events().instances(calendarId=creator_mail, eventId=updated_event["id"]).execute()
+    google_event_items = instances["items"]
+    GoogleSyncUtils.add_instance_metadata(internal_activity, google_event_items, metadata)
+
+
+def update_all_recurring_events_from_new_parent(
+    creator_mail: str, google_service: Resource, internal_activity: Activity, updates: dict
+):
+    """
+    Updates all Google-Event-Instances belonging to the same parent event.
+
+    After the external event instances have been updated, the metadata fields of the internal activities is also updated with the information of the corresponding external event instance.
+
+    Note: Do not use when updating from the original event chain parent.
+
+    :param creator_mail:        The e-mail address of the activities creator.
+    :param google_service:      The google service to interact with googles resources.
+    :param internal_activity:   The internal workbench parent activity that corresponds to the external google event.
+    :param updates:             The update information.
+    :returns:                   None
+    """
+
+    # If the old parent does not exist anymore, we cannot update the child.
+    if not (
+        current_parent_occurrence := Activity.objects.filter(
+            id=internal_activity.metadata.get("old_parent_id")
+        ).first()
+    ):
+        return warnings.warn(
+            "Could not update the recurring events on google, because the old parent activity was already deleted."
+        )
+
+    # Get the current parent event from google
+    current_google_parent_event: dict = (
+        google_service.events().get(calendarId=creator_mail, eventId=current_parent_occurrence.external_id).execute()
+    )
+
+    # Get the current recurrence rules. We need to modify them for both the current parent event and the new parent event.
+    current_parent_rrule_str: str = "\n".join(current_google_parent_event["recurrence"])
+
+    # We need to adjust the rrules to mimic the current status on the workbench. So we replace any until or count value with the current number of child activities.
+    current_parent_child_count = Activity.objects.filter(parent_occurrence=current_parent_occurrence).count()
+    new_parent_child_count = Activity.objects.filter(parent_occurrence=internal_activity).count()
+    current_parent_new_rrule: rrule = rrulestr(current_parent_rrule_str).replace(  # type: ignore
+        count=current_parent_child_count + 1, until=None
+    )
+    new_parent_rrule: rrule = rrulestr(current_parent_rrule_str).replace(count=new_parent_child_count + 1, until=None)  # type: ignore
+
+    # Converting the rrule back to str. Since the .__str__() method adds a DTSTART value, we need to remove this by using regex.
+    current_parent_new_rrule_str: str = re.sub("[DTSTART].*[\n]", "", current_parent_new_rrule.__str__()).split("T0")[
+        0
+    ]
+    new_parent_rrule_str: str = re.sub("[DTSTART].*[\n]", "", new_parent_rrule.__str__()).split("T0")[0]
+
+    # Updating the current parent with the new rrules. This will remove all the child events on google that are not in the scope of the changed rrules anymore.
+    current_google_parent_event |= {"recurrence": [current_parent_new_rrule_str]}
+    updated_current_parent_event: dict = (
+        google_service.events()
+        .update(calendarId=creator_mail, eventId=current_google_parent_event["id"], body=current_google_parent_event)
+        .execute()
+    )
+
+    # Updating the corresponding metadata
+    current_parent_metadata = current_parent_occurrence.metadata | {
+        "google_backend": {"event": updated_current_parent_event}
+    }
+    Activity.objects.filter(id=current_parent_occurrence.id).update(metadata=current_parent_metadata)
+    current_instances = (
+        google_service.events()
+        .instances(calendarId=creator_mail, eventId=updated_current_parent_event["id"])
+        .execute()
+    )
+    current_instances_google_event_items = current_instances["items"]
+    current_parent_occurrence.refresh_from_db()
+    GoogleSyncUtils.add_instance_metadata(
+        current_parent_occurrence, current_instances_google_event_items, current_parent_metadata
+    )
+
+    # Updating the new parent with the created rrules. This will create the child events in google which are in the scope of the newly created rrules.
+
+    internal_activity_query = Activity.objects.filter(id=internal_activity.id)
+    external_id = uuid4().hex
+    updates |= {"recurrence": [new_parent_rrule_str], "id": external_id}
+    internal_activity_query.update(external_id=external_id)
+    new_parent_event: dict = google_service.events().insert(calendarId=creator_mail, body=updates).execute()
+
+    # Updating the corresponding metadata
+    metadata = internal_activity.metadata | {"google_backend": {"event": new_parent_event}, "old_parent_id": None}
+    internal_activity_query.update(metadata=metadata)
+    new_instances = (
+        google_service.events().instances(calendarId=creator_mail, eventId=new_parent_event["id"]).execute()
+    )
+    new_google_event_items = new_instances["items"]
+    internal_activity.refresh_from_db()
+    GoogleSyncUtils.add_instance_metadata(internal_activity, new_google_event_items, metadata, True)

{wbcrm-2.2.4.dist-info → wbcrm-2.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wbcrm
-Version: 2.2.4
+Version: 2.2.5
 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.*

{wbcrm-2.2.4.dist-info → wbcrm-2.2.5.dist-info}/RECORD

@@ -23,6 +23,7 @@ wbcrm/filters/activities.py,sha256=aQ5pGGgeAzaskWnO25KeUiEk97BKfe8OZ543VU2_TTc,6
 wbcrm/filters/groups.py,sha256=KcjyimEoJ7LB_KIRyTIsiNneVWf5ud9CvSqJasffud0,623
 wbcrm/filters/products.py,sha256=gCiL4MVsaLZgLhyLeclWsBdKLRoYS-C7tL52_VWtfKE,1203
 wbcrm/filters/signals.py,sha256=0BSomHJQjlGV4O_JI6kPDFcghH-u6l7i0cEizhM_wOA,3819
+wbcrm/kpi_handlers/activities.py,sha256=xjq6dQUToDmYZFqaZm3Gj3deQnPeUZcH4VS2qvVtIXY,7900
 wbcrm/migrations/0001_initial_squashed_squashed_0032_productcompanyrelationship_alter_product_prospects_and_more.py,sha256=tI2lU8Z8oW_-FexgquJOC41HwqFO6OyLuRtVY9Es2Ho,166228
 wbcrm/migrations/0002_alter_activity_repeat_choice.py,sha256=OBl6j8p4l3f5k1T3TzOgQtunSXJx0M3Uk-gAuPjPxkM,1187
 wbcrm/migrations/0003_remove_activity_external_id_and_more.py,sha256=Lz4RTsGJPnR2nKZ_FH_WSD22IRVqZ6_aZcleTJT4pSM,2097
@@ -46,6 +47,9 @@ wbcrm/models/activities.py,sha256=PxrNbP03jxciQPDieHrigj6l7faiNtzwVlC6KpTC9sY,53
 wbcrm/models/groups.py,sha256=T4ikoRw6BNWL5oeHDITsGt0KJWibm3OMYppwnkBliMM,4300
 wbcrm/models/products.py,sha256=q7BOU3hPGZwolVfOPkkAFhGYYBRDGHU8ldKui9FAMPQ,2472
 wbcrm/models/recurrence.py,sha256=onftWStKx1nvaxqxOgVRO7yrHqBpke8mDQ4Erojxbtw,11998
+wbcrm/models/llm/activity_summaries.py,sha256=8dJP_aDVoakanbOnj_jYnSpeqX8b7JYtU1aXj7pj1-Y,1359
+wbcrm/models/llm/analyze_relationship.py,sha256=Po6nE9GrlwKZtL471fsWySJYDqRZGW20cLAQTdiqFGk,2346
+wbcrm/report/activity_report.py,sha256=AzSfiWne--CG4C4jpcODJtqegxcALCqxvOs9jeD4EB8,4835
 wbcrm/serializers/__init__.py,sha256=qKwo5e-Ix-Iow1RRdKFC0uZQmuSHzc8DIypIhi_E8HI,726
 wbcrm/serializers/accounts.py,sha256=pt9tu8a7P0TO9h4zMBoS1jEfdlqcQ0IaiM1S9sOT13A,4915
 wbcrm/serializers/activities.py,sha256=dVj6ta3EKh0uaXsbiZZmp9ycmW5etEvRvQFhfX4Hz3U,21756
@@ -79,6 +83,10 @@ wbcrm/synchronization/activity/backends/google/tasks.py,sha256=vQ-_z6koyAQd6kjp3
 wbcrm/synchronization/activity/backends/google/typing_informations.py,sha256=7fDaQEok0kzm_5_vrRrMiakFAh2O3j4G09XWPwYSK1I,2655
 wbcrm/synchronization/activity/backends/google/utils.py,sha256=glDYCtbQDnTrge2mpVM-GICebneaa_I9KZwCgFkwRMA,11572
 wbcrm/synchronization/activity/backends/google/request_utils/__init__.py,sha256=FQ8XwEEPtUR-DKHBgiNJQXHPduUNcJM9YiTSEH5LXmQ,530
+wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/create.py,sha256=VyAg2iftSO_hyQthX6dtL299cogIFWsmrhE_xOwZQbs,3622
+wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/delete.py,sha256=AvhoJx-vzf2RlHtDPwXy4LXQtxSGaTWQXLiHlmlFCtE,3700
+wbcrm/synchronization/activity/backends/google/request_utils/external_to_internal/update.py,sha256=4AWhTV-Rdtp4RVijULw7JlIr7ewYVLWv4s6SBb4OKuI,7810
+wbcrm/synchronization/activity/backends/google/request_utils/internal_to_external/update.py,sha256=XqEfqrLzELrxhCCovP_qvL1FECeiqxhV6caVZHfwRvk,8990
 wbcrm/synchronization/activity/backends/google/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbcrm/synchronization/activity/backends/google/tests/conftest.py,sha256=yLKwA_DjolyFXkU83ePpwxsVbtl5lrXJxYcUFLg-4fs,35
 wbcrm/synchronization/activity/backends/google/tests/test_data.py,sha256=X7uwRyRkfM1PWtZ5ycLD_ZY2sxm4V6vZ9L4DV4OAzbI,3156
@@ -150,6 +158,6 @@ wbcrm/viewsets/titles/products.py,sha256=cFAK5zljjybabk2U0KzPT2PVfV5vmO_UlJd6QlI
 wbcrm/viewsets/titles/utils.py,sha256=IaHQTmEG2OwIHS1bRv7sjuT950wefUJNi3yvPdrpNEs,1144
 wbcrm/workflows/__init__.py,sha256=biwXXPkVJugT9Vc1cwbInAUY8EnVmOauxdPz7e_2w_A,32
 wbcrm/workflows/assignee_methods.py,sha256=L7ymErtcpFgXdTMTj_lDOVJqsLAGLNT6qMlrkHGuXWM,999
-wbcrm-2.2.4.dist-info/METADATA,sha256=mcLL2JVodlT3hfV_RLfbG79cTD6gidbquJDqvH29WVQ,449
-wbcrm-2.2.4.dist-info/WHEEL,sha256=aO3RJuuiFXItVSnAUEmQ0yRBvv9e1sbJh68PtuQkyAE,105
-wbcrm-2.2.4.dist-info/RECORD,,
+wbcrm-2.2.5.dist-info/METADATA,sha256=dWfaN2T-FAkxX0XUa7ZAjWX8RXTzsv6vAJNajqbKPhk,449
+wbcrm-2.2.5.dist-info/WHEEL,sha256=aO3RJuuiFXItVSnAUEmQ0yRBvv9e1sbJh68PtuQkyAE,105
+wbcrm-2.2.5.dist-info/RECORD,,