wbcrm 2.2.1__py2.py3-none-any.whl

wbcrm/serializers/recurrence.py

@@ -0,0 +1,90 @@
+from django.db.models import Model
+from django.forms import ValidationError
+from django.utils.translation import gettext
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcrm.models.recurrence import Recurrence
+
+
+class RecurrenceModelSerializerMixin:
+    @wb_serializers.register_only_instance_resource()
+    def next_occurrence(self, instance: Model, request, user, **kwargs) -> dict:
+        resources = {}
+        if next_occurrence := instance.next_occurrence:
+            resources["next_occurrence"] = reverse(
+                f"{instance.get_endpoint_basename()}-detail", args=[next_occurrence.id], request=request
+            )
+        return resources
+
+    @wb_serializers.register_only_instance_resource()
+    def previous_occurrence(self, instance: Model, request, user, **kwargs) -> dict:
+        resources = {}
+        if previous_occurrence := instance.previous_occurrence:
+            resources["previous_occurrence"] = reverse(
+                f"{instance.get_endpoint_basename()}-detail", args=[previous_occurrence.id], request=request
+            )
+        return resources
+
+    @wb_serializers.register_only_instance_resource()
+    def get_parent_occurrence(self, instance: Model, request, user, **kwargs) -> dict:
+        resources = {}
+        if instance.parent_occurrence:
+            resources["get_parent_occurrence"] = reverse(
+                f"{instance.get_endpoint_basename()}-detail", args=[instance.parent_occurrence.id], request=request
+            )
+        return resources
+
+    @wb_serializers.register_only_instance_resource()
+    def delete_occurrences(self, instance, request, user, **kwargs):
+        resources = dict()
+        parent = instance.parent_occurrence if instance.parent_occurrence else instance
+        child_occurrences = parent.get_recurrent_valid_children()
+        if instance.period and child_occurrences.exists():
+            child_occurrences = child_occurrences.filter(period__startswith__gt=instance.period.lower)
+        if child_occurrences.exists():
+            resources["delete_next_occurrences"] = reverse(
+                f"{instance.get_endpoint_basename()}-delete-next-occurrences", args=[instance.id], request=request
+            )
+        return resources
+
+    def validate(self, data):
+        period = data.get("period", self.instance.period if self.instance else None)
+        recurrence_count = data.get("recurrence_count", self.instance.recurrence_count if self.instance else None)
+        recurrence_end = data.get("recurrence_end", self.instance.recurrence_end if self.instance else None)
+        repeat_choice = data.get("repeat_choice", self.instance.repeat_choice if self.instance else None)
+        if not period:
+            raise serializers.ValidationError({"period": gettext("Please provide a valid timeframe.")})
+
+        if recurrence_end and recurrence_count:
+            error = gettext("You can only pick either a recurrence count or an end date but not both.")
+            raise ValidationError({"recurrence_end": error, "recurrence_count": error})
+
+        if (
+            not self.instance
+            and (recurrence_end or recurrence_count)
+            and repeat_choice == Recurrence.ReoccuranceChoice.NEVER
+        ):
+            data["recurrence_end"] = None
+            data["recurrence_count"] = None
+        if data.get("repeat_choice") and data.get("repeat_choice") != Recurrence.ReoccuranceChoice.NEVER:
+            if data.get("recurrence_end") and period.lower.date() >= data.get("recurrence_end"):
+                raise ValidationError(
+                    {
+                        "recurrence_end": gettext(
+                            'The "Repeat Until" date needs to be after the "Recurrence Start" date.'
+                        )
+                    }
+                )
+            if data.get("repeat_choice") == Recurrence.ReoccuranceChoice.BUSINESS_DAILY and period.lower.weekday() > 4:
+                raise ValidationError({"period": gettext("Period must correspond to the recurrence 'Business Daily'")})
+
+        if self.instance and self.instance.period and self.instance.is_recurrent:
+            if (
+                self.instance.period.lower.date() != period.lower.date()
+                or self.instance.period.upper.date() != period.upper.date()
+            ):
+                raise ValidationError(
+                    {"period": gettext("It is only possible to change the time of the period of an occurrence.")}
+                )
+        return super().validate(data)

wbcrm/serializers/signals.py

@@ -0,0 +1,70 @@
+import functools
+from contextlib import suppress
+from urllib.parse import urlencode
+
+from django.dispatch import receiver
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.directory.serializers import (
+    CompanyModelSerializer,
+    EntryModelSerializer,
+    EntryRepresentationSerializer,
+    PersonModelListSerializer,
+    PersonModelSerializer,
+    TelephoneContactSerializer,
+)
+from wbcore.signals import add_additional_resource, add_instance_additional_resource
+from wbcrm.models import ActivityType
+
+
+@functools.lru_cache()
+def get_call_activity_type() -> int:
+    return ActivityType.objects.get_or_create(slugify_title="call", defaults={"title": "Call"})[0].id
+
+
+@receiver(add_additional_resource, sender=TelephoneContactSerializer)
+def add_telephone_contact_activity_resources(sender, serializer, instance, request, user, **kwargs):
+    res = {}
+    with suppress(Entry.DoesNotExist):
+        if entry := instance.entry:
+            activity_reverse_url = reverse("wbcrm:activity-list", args=[], request=request)
+
+            # Creates the URL for the 'Create New Call Activity'-Button
+            query_args = {
+                "type": get_call_activity_type(),
+                "new_mode": True,
+                "participants": [str(request.user.profile.id)],
+                "title": _("Call with {name}").format(name=entry.computed_str),
+            }
+
+            if entry.is_company:
+                query_args["companies"] = [str(entry.id)]
+                activity_reverse_url = f"{activity_reverse_url}?companies={entry.id}"
+            else:
+                query_args["participants"].append(str(entry.id))
+                activity_reverse_url = f"{activity_reverse_url}?participants={entry.id}"
+
+            query_args["participants"] = ",".join(query_args["participants"])
+            if "companies" in query_args:
+                query_args["companies"] = ",".join(query_args["companies"])
+        res["list_of_activities"] = activity_reverse_url
+        res["new_call"] = reverse("wbcrm:activity-list", args=[], request=request) + "?" + urlencode(query_args)
+    return res
+
+
+@receiver(add_instance_additional_resource, sender=CompanyModelSerializer)
+@receiver(add_instance_additional_resource, sender=PersonModelSerializer)
+@receiver(add_instance_additional_resource, sender=EntryModelSerializer)
+@receiver(add_instance_additional_resource, sender=PersonModelListSerializer)
+@receiver(add_instance_additional_resource, sender=EntryRepresentationSerializer)
+def add_entry_additional_resources(sender, serializer, instance, request, user, **kwargs):
+    res = {"account": f'{reverse("wbcrm:account-list", args=[], request=request)}?customer={instance.id}'}
+    if instance.is_company:
+        res["activity"] = f'{reverse("wbcrm:activity-list", request=request)}?companies={instance.id}'
+        res["interested_products"] = reverse(
+            "wbcrm:company-interestedproduct-list", args=[instance.id], request=request
+        )
+    else:
+        res["activity"] = f'{reverse("wbcrm:activity-list", request=request)}?participants={instance.id}'
+    return res

wbcrm/synchronization/activity/admin.py

@@ -0,0 +1,72 @@
+from django.contrib import admin, messages
+from django.contrib.auth import get_user_model
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.authentication.admin import UserAdmin
+from wbcrm.admin import ActivityAdmin
+from wbcrm.models import Activity
+
+from .shortcuts import get_backend
+
+User = get_user_model()
+admin.site.unregister(User)
+admin.site.unregister(Activity)
+
+
+@admin.register(Activity)
+class ActivitySyncAdmin(ActivityAdmin):
+    def delete_queryset(self, request, queryset):
+        """Given a queryset, delete it from the database."""
+        for obj in queryset.filter(is_active=True):
+            obj.delete()
+        super().delete_queryset(request, queryset)
+
+
+@admin.register(User)
+class UserSyncAdmin(UserAdmin):
+    def set_web_hook(self, request, queryset):
+        try:
+            if backend := get_backend():
+                for user in queryset:
+                    backend().set_web_hook(user)
+                self.message_user(
+                    request,
+                    _("Operation completed, we have set the webhook for {} users.").format(queryset.count()),
+                )
+            else:
+                raise ValueError("No backend set in preferences")
+        except Exception as e:
+            self.message_user(request, _("Operation Failed, {}").format(e), messages.WARNING)
+
+    def stop_web_hook(self, request, queryset):
+        try:
+            if backend := get_backend():
+                for user in queryset:
+                    backend().stop_web_hook(user)
+                self.message_user(
+                    request,
+                    _("Operation completed, we have stopped the webhook for {} users.").format(queryset.count()),
+                )
+            else:
+                raise ValueError("No backend set in preferences")
+        except Exception as e:
+            self.message_user(request, _("Operation Failed, {}").format(e), messages.WARNING)
+
+    def check_web_hook(self, request, queryset):
+        try:
+            if backend := get_backend():
+                for user in queryset:
+                    backend().check_web_hook(user)
+                self.message_user(
+                    request,
+                    _("Operation completed, we checked the webhook for {} users.").format(queryset.count()),
+                )
+            else:
+                raise ValueError("No backend set in preferences")
+        except Exception as e:
+            self.message_user(request, _("Operation Failed, {}").format(e), messages.WARNING)
+
+    actions = UserAdmin.actions + (
+        set_web_hook,
+        stop_web_hook,
+        check_web_hook,
+    )

wbcrm/synchronization/activity/backend.py

@@ -0,0 +1,207 @@
+from contextlib import suppress
+from datetime import date
+from typing import Any
+
+from django.contrib.auth import get_user_model
+from django.http import HttpRequest, HttpResponse
+from django.utils.translation import gettext_lazy
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcrm.typings import Activity as ActivityDTO
+from wbcrm.typings import ParticipantStatus as ParticipantStatusDTO
+from wbcrm.typings import User as UserDTO
+
+User = get_user_model()
+
+
+class SyncBackend:
+    METADATA_KEY = None
+
+    def open(self):
+        """
+        Allows to perform primary operations or to open a communication channel for synchronization,
+        such as defining the necessary configurations to send requests
+        """
+        pass
+
+    def close(self):
+        """
+        Close the communication channel and unset configuration
+        """
+        pass
+
+    def _validation_response(self, request: HttpRequest) -> HttpResponse:
+        """
+        send a response to the external calendar if necessary to validate the endpoint
+        """
+        return None
+
+    def _is_inbound_request_valid(self, request: HttpRequest) -> bool:
+        """
+        Valid function to ensure that the request received meets expectations
+        """
+        raise NotImplementedError
+
+    def _get_events_from_request(self, request: HttpRequest) -> list[dict[str, Any]]:
+        """
+        list of events following the notification received
+        """
+        raise NotImplementedError
+
+    def _deserialize(self, event: dict[str, Any]) -> tuple[ActivityDTO, bool, UserDTO]:
+        """
+        convert the dictionary received to a valid format of an activity
+        """
+        raise NotImplementedError()
+
+    def _serialize(self, activity_dto: ActivityDTO, created: bool = False) -> dict[str, Any]:
+        """
+        convert activity data transfer object to event dictionary
+        """
+        raise NotImplementedError()
+
+    def _stream_deletion(self, activity_dto: ActivityDTO):
+        """
+        allow the deletion of the event in the external calendar
+        we use the event_id stored in activity_dto's metadata to retrieve the event
+        """
+        raise NotImplementedError()
+
+    def _stream_creation(
+        self, activity_dto: ActivityDTO, activity_dict: dict[str, Any]
+    ) -> tuple[ActivityDTO, dict[str, Any]]:
+        """
+        allow the creation of the event in the external calendar
+        param: activity_dict: dictionary used to create the event
+
+        we return a tuple of activity, metadata which contains the external id to be store in the activity
+        """
+        raise NotImplementedError()
+
+    def _stream_update(
+        self,
+        activity_dto: ActivityDTO,
+        activity_dict: dict[str, Any],
+        only_participants_changed: bool = False,
+        external_participants: list = [],
+        keep_external_description: bool = False,
+    ) -> tuple[ActivityDTO, dict[str, Any]]:
+        """
+        allow to update the event in the external calendar
+        param: activity_dict: dictionary used to update the event
+               activity_dto: we use the metadata of the activity to retrieve the event
+               only_participants_changed: boolean to know if only the participants need to be update
+               external_participants: list of external participants, that must be added to the current list of participants to avoid their deletion when the activity is updated
+               keep_external_description: boolean to know if the description must be deleted or not before the update of the event
+        """
+        raise NotImplementedError()
+
+    def _stream_extension_event(self, activity_dto: ActivityDTO) -> None:
+        """
+        Extend external event with custom data
+        this allows us for example to add additional information to the event to easily identify it for a recurring activities
+        """
+        pass
+
+    def _stream_forward(self, activity_dto: ActivityDTO, participants_dto: list[ParticipantStatusDTO]):
+        """
+        allow to forward an event to a new participant. the external calendar
+        send an invitation to all participants and avoid sending an update of the activity to all participants
+        """
+        raise NotImplementedError()
+
+    def _stream_participant_change(
+        self, participant_dto: ParticipantStatusDTO, is_deleted: bool = False, wait_before_changing: bool = False
+    ):
+        """
+        allow to update the status of an event participant
+        """
+        raise NotImplementedError()
+
+    def _set_web_hook(self, user: "User") -> dict[str, dict[str, Any]]:
+        """
+        allows to activate the webhook for a user
+        returns a dictionary that will be stored in the metadata of the ser
+        """
+        raise NotImplementedError()
+
+    def _stop_web_hook(self, user: "User") -> dict[str, dict[str, Any]]:
+        """
+        allows to strop the webhook for a user and deletes the data stored in the metadata
+        """
+        raise NotImplementedError()
+
+    def _check_web_hook(self, user: "User") -> bool:
+        """
+        return a boolean to know if a subscription is activated or not for a user
+        """
+        raise NotImplementedError()
+
+    def set_web_hook(self, user: "User"):
+        """
+        allows to be sure that the metadata are saved by specifying the backend type.
+        """
+        new_metadata = self._set_web_hook(user)
+        user.metadata.setdefault(self.METADATA_KEY, {})
+        user.metadata[self.METADATA_KEY] = new_metadata
+        user.save()
+
+    def stop_web_hook(self, user: "User"):
+        new_metadata = self._stop_web_hook(user)
+        user.metadata.setdefault(self.METADATA_KEY, {})
+        user.metadata[self.METADATA_KEY] = new_metadata
+        user.save()
+
+    def check_web_hook(self, user: "User") -> bool:
+        try:
+            return self._check_web_hook(user)
+        except NotImplementedError:
+            return False
+
+    def renew_web_hooks(self) -> None:
+        """
+        Allows to renew existing webhooks of all users
+        """
+        pass
+
+    def _get_webhook_inconsistencies(self) -> str:
+        """
+        return a message of anomalies that will be notified to the administrator/persons set in the preferences
+        """
+        raise NotImplementedError()
+
+    def notify_admins_of_webhook_inconsistencies(self, emails: list) -> None:
+        """
+        the purpose is to make sure that the authorized persons receive the messages in case a webhook has been deactivated or not renewed correctly.
+        """
+        with suppress(NotImplementedError):
+            if emails and (message := self._get_webhook_inconsistencies()):
+                for recipient in User.objects.filter(email__in=emails):
+                    send_notification(
+                        code="wbcrm.activity_sync.admin",
+                        title=gettext_lazy("Notify admins of event webhook inconsistencies - {}").format(date.today()),
+                        body=f"<ul>{message}</ul>",
+                        user=recipient,
+                    )
+
+    def get_external_event(self, activity_dto: ActivityDTO) -> dict:
+        """
+        Get an event of external calendar.
+        """
+        pass
+
+    def get_external_participants(
+        self, activity_dto: ActivityDTO, internal_participants_dto: list[ParticipantStatusDTO]
+    ) -> list[str, Any]:
+        """
+        Get external participants of an external event
+        """
+        return []
+
+    def _is_participant_valid(self, user: "User") -> bool:
+        return user.is_active and user.is_register
+
+    def is_valid(self, activity: ActivityDTO) -> bool:
+        # Synchronize only if the creator or at least one participant has an active subscription
+        participants = [activity.creator.email] if activity.creator else []
+        participants.extend(list(map(lambda x: x.person.email, activity.participants)))
+        return any([self._is_participant_valid(user) for user in User.objects.filter(email__in=set(participants))])

wbcrm/synchronization/activity/backends/google/__init__.py

@@ -0,0 +1,2 @@
+from .google_calendar_backend import GoogleCalendarBackend
+from .tasks import google_webhook_resubscription