wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/synchronization/activity/dynamic_preferences_registry.py

@@ -0,0 +1,119 @@
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import BooleanPreference, StringPreference
+
+general = Section("wbactivity_sync")
+
+
+@global_preferences_registry.register
+class BackendCalendarPreference(StringPreference):
+    section = general
+    name = "sync_backend_calendar"
+    default = ""
+
+    verbose_name = _("Synchronization Backend Calendar")
+    help_text = _("The Backend Calendar to synchronize activities with an external calendar.")
+
+
+@global_preferences_registry.register
+class SyncPastActivity(BooleanPreference):
+    section = general
+    name = "sync_past_activity"
+    default = False
+
+    verbose_name = _("Synchronization Past Activity")
+
+
+@global_preferences_registry.register
+class SyncCancelledActivity(BooleanPreference):
+    section = general
+    name = "sync_cancelled_activity"
+    default = True
+
+    verbose_name = _("Cancel Internal Activity Instead Of Deleting")
+    help_text = _(
+        "When an activity is deleted in an external calendar the corresponding workbench activity can be cancelled (default) or also deleted."
+    )
+
+
+@global_preferences_registry.register
+class SyncCancelledExternalActivity(BooleanPreference):
+    section = general
+    name = "sync_cancelled_external_activity"
+    default = False
+
+    verbose_name = _("Cancel External Activity With One Non-Attending Internal Participant")
+    help_text = _(
+        "When an activity was created by an external person and has only one internal participant the activity in the workbench can be canceled if this participant doesn't choose to attend."
+    )
+
+
+@global_preferences_registry.register
+class SyncActivityDescription(BooleanPreference):
+    section = general
+    name = "sync_activity_description"
+    default = True
+
+    verbose_name = _("Synchronize Activity Description")
+
+
+@global_preferences_registry.register
+class SyncExternalParticipants(BooleanPreference):
+    section = general
+    name = "sync_external_participants"
+    default = False
+
+    verbose_name = _("Synchronize External Participants From Internal Calendar To External Calendar")
+
+
+@global_preferences_registry.register
+class SyncReplannedReviewedActivityCreatesNewActivity(BooleanPreference):
+    section = general
+    name = "sync_create_new_activity_on_replanned_reviewed_activity"
+    default = False
+
+    verbose_name = _("Create New Activity When Replanning Passed Reviewed Activities")
+    help_text = _(
+        "If an activity with a past end date (already passed and reviewed) is moved to a future date, a new activity will automatically be created for the updated schedule."
+    )
+
+
+@global_preferences_registry.register
+class GoogleSyncCredentials(StringPreference):
+    section = general
+    name = "google_sync_credentials"
+    default = ""
+    verbose_name = _("Google Synchronization Credentials")
+    help_text = "Dict. Keys: 'url', 'type', 'project_id', 'private_key_id', 'private_key', 'client_email', 'client_id', 'auth_uri', 'token_uri', 'auth_provider_x509_cert_url', 'client_x509_cert_url'"
+
+
+@global_preferences_registry.register
+class OutlookSyncCredentials(StringPreference):
+    section = general
+    name = "outlook_sync_credentials"
+    default = ""
+    verbose_name = _("Outlook Synchronization Credentials")
+    help_text = '{"notification_url": "", "authority": "", "client_id": "", "client_secret": "", "token_endpoint": "", "graph_url": ""}'
+
+
+@global_preferences_registry.register
+class OutlookSyncAccesToken(StringPreference):
+    section = general
+    name = "outlook_sync_access_token"
+    default = ""
+
+    verbose_name = _("Microsoft Graph Access Token")
+    help_text = _("The access token obtained from subscriptions to Microsoft used for authentication pruposes")
+
+
+@global_preferences_registry.register
+class OutlookSyncClientState(StringPreference):
+    section = general
+    name = "outlook_sync_client_state"
+    default = "secretClientValue"
+
+    verbose_name = _("Microsoft Graph Webhook Secret Client State")
+    help_text = _(
+        "Secret Client Value defined during subscription, it will be injected into the webhook notification against spoofing"
+    )

wbcrm/synchronization/activity/preferences.py

@@ -0,0 +1,27 @@
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def can_sync_past_activity() -> bool:
+    return global_preferences_registry.manager()["wbactivity_sync__sync_past_activity"]
+
+
+def can_sync_cancelled_activity() -> bool:
+    return global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_activity"]
+
+
+def can_sync_cancelled_external_activity() -> bool:
+    return global_preferences_registry.manager()["wbactivity_sync__sync_cancelled_external_activity"]
+
+
+def can_sync_create_new_activity_on_replanned_reviewed_activity() -> bool:
+    return global_preferences_registry.manager()[
+        "wbactivity_sync__sync_create_new_activity_on_replanned_reviewed_activity"
+    ]
+
+
+def can_synchronize_activity_description() -> bool:
+    return global_preferences_registry.manager()["wbactivity_sync__sync_activity_description"]
+
+
+def can_synchronize_external_participants() -> bool:
+    return global_preferences_registry.manager()["wbactivity_sync__sync_external_participants"]

wbcrm/synchronization/activity/shortcuts.py

@@ -0,0 +1,16 @@
+from contextlib import suppress
+
+from django.conf import settings
+from dynamic_preferences.exceptions import NotFoundInRegistry
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.utils.importlib import import_from_dotted_path
+
+
+def get_backend():
+    from wbcrm.synchronization.activity.controller import ActivityController
+
+    if not settings.DEBUG:
+        with suppress(NotFoundInRegistry):
+            if backend := global_preferences_registry.manager()["wbactivity_sync__sync_backend_calendar"]:
+                backend = import_from_dotted_path(backend)
+                return ActivityController(backend=backend)

wbcrm/synchronization/activity/tasks.py

@@ -0,0 +1,21 @@
+from celery import shared_task
+
+from .shortcuts import get_backend
+
+
+@shared_task(queue="synchronization")
+def periodic_notify_admins_of_webhook_inconsistencies_task(emails: list | None = None):
+    """
+    Periodic tasks to notify webhook inconsistencies
+    """
+    if emails and (controller := get_backend()):
+        controller.backend.notify_admins_of_webhook_inconsistencies(emails)
+
+
+@shared_task(queue="synchronization")
+def periodic_renew_web_hooks_task():
+    """
+    Periodic tasks to renew active webhooks
+    """
+    if controller := get_backend():
+        controller.backend.renew_web_hooks()

wbcrm/synchronization/activity/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+
+from wbcrm.synchronization.activity.views import event_watch
+
+urlpatterns = [
+    path("event_watch", event_watch, name="event_watch"),
+]

wbcrm/synchronization/activity/utils.py

@@ -0,0 +1,46 @@
+from typing import Any
+
+
+def flattened_metadata_lookup(obj: dict, key_string: str = "") -> tuple[str, Any]:
+    """
+    allows to flatten in nested dictionary which can be used in a lookup query
+    """
+    if isinstance(obj, dict):
+        key_string = key_string + "__" if key_string else key_string
+        for k in obj:
+            yield from flattened_metadata_lookup(obj[k], key_string + str(k))
+    else:
+        if isinstance(obj, list):
+            yield key_string + "__contains", obj
+        else:
+            yield key_string, obj
+
+
+def merge_nested_dict(dct: dict, nested_to_merge: dict):
+    """
+    allows to merge 2 nested dictionaries
+    """
+    for k in nested_to_merge.keys():
+        if k in dct:
+            if isinstance(dct[k], dict) and isinstance(nested_to_merge[k], dict):  # noqa
+                merge_nested_dict(dct[k], nested_to_merge[k])
+            else:
+                if not isinstance(dct[k], list):
+                    dct[k] = [dct[k]]
+                dct[k].append(nested_to_merge[k])
+        else:
+            dct[k] = nested_to_merge[k]
+
+
+def flattened_dict_into_nested_dict(obj: dict) -> dict:
+    """
+    allows to nest a flattened dictionary
+    """
+    nested = {}
+    for key, value in obj.items():
+        keys = key.split(".")
+        dct = {keys.pop(): value}
+        while keys:
+            dct = {keys.pop(): dct}
+        merge_nested_dict(nested, dct)
+    return nested

wbcrm/synchronization/activity/views.py

@@ -0,0 +1,41 @@
+from celery import shared_task
+from django.db.utils import OperationalError
+from django.http import HttpRequest, HttpResponse
+from django.views.decorators.csrf import csrf_exempt
+
+from wbcrm.models.events import Event
+
+from .shortcuts import get_backend
+
+
+@shared_task(
+    queue="synchronization",
+    default_retry_delay=5,
+    autoretry_for=(OperationalError,),
+    max_retries=4,
+    retry_backoff=True,
+)
+def handle_inbound_as_task(event: dict):
+    """
+    the events received from the webhook are handled in a task
+    which will allow to create, modify or delete the activity without interrupting the main server
+    """
+    if controller := get_backend():
+        event_object = Event.objects.create(data=event)
+        controller.handle_inbound(event=event, event_object_id=event_object.id)
+
+
+@csrf_exempt
+def event_watch(request: HttpRequest) -> HttpResponse:
+    # TODO this is unsecure as it is prone to DDOS attack
+    status_code = 200
+    try:
+        if controller := get_backend():
+            if response := controller.handle_inbound_validation_response(request):
+                return response
+            for event in controller.get_events_from_inbound_request(request):
+                handle_inbound_as_task.delay(event)
+    except Exception as e:
+        print(e)  # noqa: T201
+        status_code = 500
+    return HttpResponse(status=status_code)

wbcrm/synchronization/admin.py

@@ -0,0 +1 @@
+import wbcrm.synchronization.activity.admin  # noqa

wbcrm/synchronization/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+class WbSyncConfig(AppConfig):
+    name = "wbcrm.synchronization"
+
+    def ready(self) -> None:
+        from wbcrm.synchronization.management import initialize_task
+
+        post_migrate.connect(
+            initialize_task,
+            dispatch_uid="wbcrm.synchronization.initialize_task",
+        )

wbcrm/synchronization/dynamic_preferences_registry.py

@@ -0,0 +1 @@
+import wbcrm.synchronization.activity.dynamic_preferences_registry  # noqa

wbcrm/synchronization/management.py

@@ -0,0 +1,36 @@
+from django.apps import apps as global_apps
+from django.db import DEFAULT_DB_ALIAS
+from django_celery_beat.models import CrontabSchedule, PeriodicTask
+
+
+def initialize_task(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs):
+    crontab1, _ = CrontabSchedule.objects.get_or_create(
+        minute="0",
+        hour="1",
+        day_of_week="*",
+        day_of_month="*",
+        month_of_year="*",
+    )
+    crontab2, _ = CrontabSchedule.objects.get_or_create(
+        minute="0",
+        hour="7",
+        day_of_week="*",
+        day_of_month="*",
+        month_of_year="*",
+    )
+
+    # Automatically register the utility periodic tasks
+    PeriodicTask.objects.update_or_create(
+        task="wbcrm.synchronization.activity.tasks.periodic_renew_web_hooks_task",
+        defaults={
+            "name": "Wbactivity_sync: Renewal of the Activity Sync webhook",
+            "crontab": crontab1,
+        },
+    )
+    PeriodicTask.objects.update_or_create(
+        task="wbcrm.synchronization.activity.tasks.periodic_notify_admins_of_webhook_inconsistencies_task",
+        defaults={
+            "name": "Wbactivity_sync: Notification of webhook inconsistencies",
+            "crontab": crontab2,
+        },
+    )

wbcrm/synchronization/tasks.py

@@ -0,0 +1 @@
+from .activity.tasks import *  # noqa

wbcrm/synchronization/urls.py

@@ -0,0 +1,5 @@
+from django.urls import include, path
+
+urlpatterns = [
+    path("activity/", include(("wbcrm.synchronization.activity.urls", "activity"), namespace="activity")),
+]

wbcrm/tasks.py

@@ -0,0 +1,264 @@
+from __future__ import absolute_import, unicode_literals
+
+import logging
+from datetime import date, datetime, time, timedelta
+
+from celery import shared_task
+from django.contrib.auth import get_user_model
+from django.db.backends.postgresql.psycopg_any import DateTimeTZRange
+from django.db.models import (
+    F,
+    FloatField,
+    Func,
+    Max,
+    OuterRef,
+    Q,
+    QuerySet,
+    Subquery,
+    Sum,
+    Value,
+)
+from django.db.models.functions import Cast, Coalesce, Least
+from django.template.loader import render_to_string
+from django.utils import timezone
+from django.utils.timezone import make_aware
+from django.utils.translation import gettext as _
+from dynamic_preferences.registries import global_preferences_registry
+from rest_framework.reverse import reverse
+from wbcore.contrib.directory.models import Company, Person
+from wbcore.contrib.notifications.dispatch import send_notification
+
+from wbcrm.models import Activity, ActivityType
+
+logger = logging.getLogger()
+User = get_user_model()
+
+
+@shared_task
+def notify(time_offset: int = 60, now: datetime | None = None):
+    """
+    Cron task that runs every 60s and checks which activities will happen during the notify interval
+
+    Arguments:
+        time_offset (int):  The notification period. Defaults to 60.
+        now (datetime | None, optional):  The time at which activity needs to be checked for a notification. Defaults to None.
+    """
+
+    if not now:
+        now = timezone.now()
+    base_queryset: QuerySet[Activity] = Activity.objects.filter(Q(status=Activity.Status.PLANNED))
+    reminder_choices = Activity.ReminderChoice.values
+
+    # we don't notify activity if Reminder is Never
+    reminder_choices.remove(Activity.ReminderChoice.NEVER)
+    for reminder in reminder_choices:
+        # get the reminder correspondance in minutes
+        reminder_minutes = Activity.ReminderChoice.get_minutes_correspondance(reminder)
+        reminder_range = DateTimeTZRange(
+            now + timedelta(minutes=reminder_minutes),
+            now + timedelta(minutes=reminder_minutes) + timedelta(seconds=time_offset),
+        )  # type: ignore #ErrMsg: Expected no arguments to "DateTimeTZRange" constructor
+        # get all incoming activity with same reminder that happen during the notify interval
+        upcoming_occurence = base_queryset.filter(
+            reminder_choice=reminder, period__startswith__contained_by=reminder_range
+        )
+        for activity in upcoming_occurence:
+            participants = activity.get_participants()
+
+            # For each Employee in the activity participants
+            for employee in Person.objects.filter_only_internal().filter(id__in=participants.values("id")).all():
+                # formant and create Notification
+                activity_type_label = activity.type.title
+                desc = (
+                    activity.description
+                    if activity.description and activity.description not in ["", "<p></p>"]
+                    else None
+                )
+                message = render_to_string(
+                    "email/activity.html",
+                    {
+                        "participants": participants,
+                        "type": activity_type_label,
+                        "title": activity.title,
+                        "start": activity.period.lower,
+                        "end": activity.period.upper,
+                        "description": desc,
+                    },
+                )
+                send_notification(
+                    code="wbcrm.activity.reminder",
+                    title=_("{type} in {reminder} Minutes").format(
+                        type=activity_type_label, reminder=reminder_minutes
+                    ),
+                    body=message,
+                    user=employee.user_account,
+                    reverse_name="wbcrm:activity-detail",
+                    reverse_args=[activity.pk],
+                )
+
+
+@shared_task
+def yesterdays_activity_summary(yesterday: date | None = None, report_receiver_user_ids: list[int] | None = None):
+    """A daily task that sends a summary of all employees' yesterday's activities to the users assigned to this task
+
+    Args:
+        yesterday (date | None, optional): Date of the previous day. Defaults to None.
+    """
+
+    if not yesterday:
+        yesterday = date.today() - timedelta(days=1)
+    yesterday = datetime.combine(yesterday, time(0, 0, 0))  # we convert the date to datetime
+    time_range = DateTimeTZRange(make_aware(yesterday), make_aware(yesterday + timedelta(days=1)))  # type: ignore #ErrMsg: Expected no arguments to "DateTimeTZRange" constructor
+
+    # Create the list of all employees' activities for yesterday
+    employees_list: list[Person] = list(Person.objects.filter_only_internal())
+    internal_activities: QuerySet[Activity] = (
+        Activity.objects.exclude(status=Activity.Status.CANCELLED)
+        .filter(period__overlap=time_range, participants__in=employees_list)
+        .order_by("period__startswith")
+    )
+
+    if not (internal_activities.exists() or report_receiver_user_ids):
+        return
+
+    activity_lists: list[list[dict]] = []  # contains an activity list for each employee
+    employee_names = []
+    for employee in employees_list:
+        if internal_activities.filter(participants=employee).exists():
+            employees_activities = internal_activities.filter(participants=employee)
+            # Create activity list with formatted activity dictionaries for employee
+            activity_lists.append(
+                [
+                    {
+                        "type": activity.type.title,
+                        "title": activity.title,
+                        "start": activity.period.lower,  # type: ignore #ErrMsg: Cannot access member "lower" for type "DateTimeTZRange"
+                        "end": activity.period.upper,  # type: ignore #ErrMsg: Cannot access member "upper" for type "DateTimeTZRange"
+                        "endpoint": reverse("wbcrm:activity-detail", args=[activity.pk]),
+                    }
+                    for activity in employees_activities
+                ]
+            )
+            employee_names.append(employee.full_name)
+
+    # Create the notification for each person with the right permission
+    for user in User.objects.filter(id__in=report_receiver_user_ids).distinct():
+        context = {
+            "map_activities": zip(employee_names, activity_lists, strict=False),
+            "activities_count": internal_activities.count(),
+            "report_date": yesterday.strftime("%d.%m.%Y"),
+        }
+        message = render_to_string("email/global_daily_summary.html", context)
+        send_notification(
+            code="wbcrm.activity.global_daily_summary",
+            title=_("Activity Summary {}").format(yesterday.strftime("%d.%m.%Y")),
+            body=message,
+            user=user,
+        )
+
+
+@shared_task
+def finish(now: datetime | None = None):
+    """Cron task running every X Seconds. Checks all activities that have finished and sends a reminder to review the activity to the assigned person.
+
+    Args:
+        now (datetime | None, optional): Current datetime. Defaults to None.
+    """
+
+    if not now:
+        now = timezone.now()
+    # Get all finished activities during the cron task interval
+    finished_activities: QuerySet[Activity] = Activity.objects.filter(
+        Q(status=Activity.Status.PLANNED.name)
+        & Q(repeat_choice=Activity.ReoccuranceChoice.NEVER)
+        & Q(period__endswith__lte=now)
+    )
+
+    # For each of these activities, Send the Notification to the person in charge of that activity
+    for activity in finished_activities:
+        activity.finish()
+        activity.save()
+        if (assignee := activity.assigned_to) and assignee.is_internal and assignee.user_account:
+            send_notification(
+                code="wbcrm.activity.finished",
+                title=_("Activity Finished"),
+                body=_('The activity "{title}" just finished and you are in charge of it. Please review.').format(
+                    title=activity.title
+                ),
+                user=assignee.user_account,
+                reverse_name="wbcrm:activity-detail",
+                reverse_args=[activity.pk],
+            )
+
+
+@shared_task
+def default_activity_heat_calculation(check_datetime: datetime | None = None):
+    """A script that calculates the activity heat of companies and
+    persons on a scale from 0.0 to 1.0. The type and time interval of
+    completed activities serve as the basis for the heat calculation for companies. A person's rating is based
+    on the score of the person's employer.
+
+    Args:
+        check_datetime (datetime | None, optional): The datetime of the activity heat check. Defaults to None.
+    """
+
+    if not check_datetime:
+        check_datetime = timezone.now()
+
+    class JulianDay(Func):
+        """
+        The Julian day is the continuous count of days since the beginning of the Julian period.
+        """
+
+        function = ""
+        output_field = FloatField()  # type: ignore #ErrMsg: Expression of type "FloatField[float]" cannot be assigned to declared type "property"
+
+        def as_postgresql(self, compiler, connection):
+            self.template = "CAST (to_char(%(expressions)s, 'J') AS INTEGER)"
+            return self.as_sql(compiler, connection)
+
+    global_preferences_manager = global_preferences_registry.manager()
+    main_company: int = global_preferences_manager["directory__main_company"]
+
+    external_employees: QuerySet[Person] = Person.objects.exclude(id__in=Person.objects.filter_only_internal())
+    external_companies: QuerySet[Company] = Company.objects.exclude(id=main_company)
+    # Calculate the activity heat of a person in the last 180 days.
+    activity_score = (
+        Activity.objects.filter(
+            companies__id=OuterRef("id"),
+            status__in=["REVIEWED", "FINISHED"],
+            period__endswith__gte=check_datetime - timedelta(days=180),
+            period__endswith__lte=check_datetime,
+        )
+        .annotate(
+            ratio=JulianDay(Value(check_datetime)) - JulianDay(F("period__endswith")),
+            date_score=(Value(365) - F("ratio")) / Value(365.0),
+            score=Cast(F("type__score"), FloatField()) * F("date_score"),
+        )
+        .values("companies__id")
+        .annotate(sum_score=Sum(F("score")))
+        .values("sum_score")
+    )
+
+    company_score = (
+        Company.objects.filter(
+            id=OuterRef("id"),
+        )
+        .annotate(
+            norm_score=Coalesce(
+                Subquery(activity_score) / float(ActivityType.Score.MAX),
+                Value(0.0),
+            ),
+            abs_norm_score=Least(F("norm_score"), 1.0),
+        )
+        .values("abs_norm_score")
+    )
+    employer_max_score = (
+        external_companies.filter(employees__id=OuterRef("id"))
+        .values("employees__id")
+        .annotate(max_score=Max("activity_heat"))
+        .values("max_score")
+    )
+
+    external_companies.update(activity_heat=Subquery(company_score))
+    external_employees.filter(employers__id__in=external_companies).update(activity_heat=Subquery(employer_max_score))