wbcrm 2.2.1__py2.py3-none-any.whl

wbcrm/synchronization/activity/signals.py

@@ -0,0 +1,28 @@
+from django.dispatch import receiver
+from wbcore.contrib.agenda.signals import complete_post_delete, complete_post_save
+from wbcrm.typings import Activity as ActivityDTO
+from wbcrm.typings import ParticipantStatus as ParticipantStatusDTO
+
+from .controller import ActivityController
+
+
+@receiver(complete_post_save, sender="wbcrm.Activity")
+def pre_save_activity(sender, activity_dto: ActivityDTO, pre_save_activity_dto: ActivityDTO = None, **kwargs):
+    ActivityController().handle_outbound(activity_dto, old_activity_dto=pre_save_activity_dto)
+
+
+@receiver(complete_post_delete, sender="wbcrm.Activity")
+def pre_delete_activity(sender, activity_dto: ActivityDTO, pre_delete_activity_dto: ActivityDTO, **kwargs):
+    ActivityController().handle_outbound(activity_dto, old_activity_dto=pre_delete_activity_dto, is_deleted=True)
+
+
+@receiver(complete_post_save, sender="wbcrm.ActivityParticipant")
+def pre_save_activity_participant(
+    sender, participant_dto: ParticipantStatusDTO, pre_save_participant_dto: ParticipantStatusDTO = None, **kwargs
+):
+    ActivityController().handle_outbound_participant(participant_dto, old_participant_dto=pre_save_participant_dto)
+
+
+@receiver(complete_post_delete, sender="wbcrm.ActivityParticipant")
+def pre_delete_activity_participant(sender, participant_dto: ParticipantStatusDTO, **kwargs):
+    ActivityController().handle_outbound_participant(participant_dto, is_deleted=True)

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 (backend := get_backend()):
+        backend().notify_admins_of_webhook_inconsistencies(emails)
+
+
+@shared_task(queue="synchronization")
+def periodic_renew_web_hooks_task():
+    """
+    Periodic tasks to renew active webhooks
+    """
+    if backend := get_backend():
+        backend().renew_web_hooks()

wbcrm/synchronization/activity/urls.py

@@ -0,0 +1,6 @@
+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, v in nested_to_merge.items():
+        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,37 @@
+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 .controller import ActivityController
+
+
+@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
+    """
+    ActivityController().handle_inbound(event)
+
+
+@csrf_exempt
+def event_watch(request: HttpRequest) -> HttpResponse:
+    # TODO this is unsecure as it is prone to DDOS attack
+    status_code = 200
+    try:
+        controller = ActivityController()
+        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,15 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+class WbSyncConfig(AppConfig):
+    name = "wbcrm.synchronization"
+
+    def ready(self) -> None:
+        import wbcrm.synchronization.activity.signals  # noqa
+        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,312 @@
+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.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 psycopg.types.range import TimestamptzRange
+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 = TimestamptzRange(
+            now + timedelta(minutes=reminder_minutes),
+            now + timedelta(minutes=reminder_minutes) + timedelta(seconds=time_offset),
+        )  # type: ignore #ErrMsg: Expected no arguments to "TimestamptzRange" 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 = TimestamptzRange(make_aware(yesterday), make_aware(yesterday + timedelta(days=1)))  # type: ignore #ErrMsg: Expected no arguments to "TimestamptzRange" 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 "TimestamptzRange"
+                        "end": activity.period.upper,  # type: ignore #ErrMsg: Cannot access member "upper" for type "TimestamptzRange"
+                        "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),
+            "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.daily_summary",
+            title=_("Activity Summary {}").format(yesterday.strftime("%d.%m.%Y")),
+            body=message,
+            user=user,
+        )
+
+
+@shared_task
+def todays_activity_summary(today: date | None = None):
+    """Creates a summary of the daily upcoming activities for all employees
+
+    Args:
+        today (date | None, optional): Date of today. Defaults to None.
+    """
+
+    if not today:
+        today = date.today()
+    tz_info = timezone.get_current_timezone()
+    today_range = TimestamptzRange(
+        lower=datetime.combine(today, time(0, 0, 0)).replace(tzinfo=tz_info),
+        upper=datetime.combine(today + timedelta(days=1), time(0, 0, 0).replace(tzinfo=tz_info)),
+    )
+
+    for employee in Person.objects.filter_only_internal():
+        # Get all the employee's activities from that day
+        activity_qs: QuerySet[Activity] = (
+            Activity.objects.exclude(status=Activity.Status.CANCELLED)
+            .filter(period__overlap=today_range, participants=employee)
+            .order_by("period__startswith")
+        )
+
+        # Create the formatted activity dictionaries
+        activity_list = []
+        for activity in activity_qs:
+            activity_list.append(
+                {
+                    "type": activity.type.title,
+                    "title": activity.title,
+                    "start": activity.period.lower,
+                    "end": activity.period.upper,
+                    "endpoint": reverse("wbcrm:activity-detail", args=[activity.pk]),
+                }
+            )
+
+        # Create the proper notification for each employee
+        if activity_list and employee.primary_email_contact():
+            context = {"activities": activity_list}
+            message = render_to_string("email/daily_summary.html", context)
+            send_notification(
+                code="wbcrm.activity.daily_summary",
+                title=_("Your Schedule for Today"),
+                body=message,
+                user=employee.user_account,
+            )
+
+
+@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))