wbintegrator_office365 2.2.1__py2.py3-none-any.whl

wbintegrator_office365/models/subscription.py

@@ -0,0 +1,144 @@
+from celery import chain, shared_task
+from django.db import models, transaction
+from django.db.models import Q
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+from wbcore.models import WBModel
+from wbintegrator_office365.importer import MicrosoftGraphAPI
+
+
+class Subscription(WBModel):
+    class Meta:
+        verbose_name = "Subscription"
+        verbose_name_plural = "Subscriptions"
+
+    class TypeResource(models.TextChoices):
+        CALLRECORD = "CALLRECORD", "Call Record"
+        CALENDAR = "CALENDAR", "Calendar"
+
+    is_enable = models.BooleanField(default=True)
+    subscription_id = models.CharField(max_length=255, null=True, blank=True)
+    change_type = models.CharField(max_length=255, null=True, blank=True)
+    notification_url = models.CharField(max_length=255, null=True, blank=True)
+    resource = models.CharField(max_length=255, null=True, blank=True)
+    type_resource = models.CharField(
+        max_length=32,
+        choices=TypeResource.choices,
+        default=TypeResource.CALLRECORD,
+        verbose_name="Type of the resource",
+    )
+    tenant_user = models.ForeignKey(
+        "wbintegrator_office365.TenantUser",
+        related_name="subscriptions",
+        null=True,
+        blank=True,
+        on_delete=models.deletion.SET_NULL,
+        verbose_name="Tenant User",
+    )
+    expiration_date = models.DateTimeField(null=True, blank=True, verbose_name="Expiration Date")
+    created = models.DateTimeField(auto_now_add=True, verbose_name="Created")
+    application_id = models.CharField(null=True, blank=True, max_length=255)
+    creator_id = models.CharField(null=True, blank=True, max_length=255)
+    client_state = models.CharField(null=True, blank=True, max_length=255)
+    latest_supported_tls_version = models.CharField(null=True, blank=True, max_length=255)
+    notification_content_type = models.CharField(null=True, blank=True, max_length=255)
+    odata_context = models.CharField(null=True, blank=True, max_length=255)
+    encryption_certificate_id = models.CharField(null=True, blank=True, max_length=255)
+    encryption_certificate = models.CharField(null=True, blank=True, max_length=255)
+    include_resource_data = models.CharField(null=True, blank=True, max_length=255)
+    notification_query_options = models.CharField(null=True, blank=True, max_length=255)
+
+    def __str__(self):
+        return f"{self.subscription_id}: {self.expiration_date}"
+
+    def resubscribe(self) -> None:
+        if self.subscription_id and (data := MicrosoftGraphAPI()._renew_subscription(self.subscription_id)):
+            Subscription.objects.filter(id=self.id).update(
+                expiration_date=data.get("expiration"), notification_url=data.get("notification_url")
+            )
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbintegrator_office365:subscription"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbintegrator_office365:subscriptionrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{subscription_id}}: {{expiration_date}}"
+
+
+@shared_task
+def subscribe(instance_id, resource, minutes=4230, change_type="created, updated"):
+    with transaction.atomic():
+        data = MicrosoftGraphAPI()._subscribe(resource, minutes, change_type=change_type)
+        if data.get("id"):
+            instance = Subscription.objects.get(id=instance_id)
+            if instance.type_resource == Subscription.TypeResource.CALLRECORD:
+                instance.tenant_user = None
+            instance.subscription_id = data.get("id")
+            instance.change_type = data.get("change_type")
+            instance.notification_url = data.get("notification_url")
+            instance.resource = data.get("resource")
+            instance.expiration_date = data.get("expiration")
+            instance.application_id = data.get("application_id")
+            instance.creator_id = data.get("creator_id")
+            instance.client_state = data.get("client_state")
+            instance.latest_supported_tls_version = data.get("latest_supported_tls_version")
+            instance.notification_content_type = data.get("notification_content_type")
+            instance.odata_context = data.get("odata_context")
+            instance.encryption_certificate_id = data.get("encryption_certificate_id")
+            instance.encryption_certificate = data.get("encryption_certificate")
+            instance.include_resource_data = data.get("include_resource_data")
+            instance.notification_query_options = data.get("notification_query_options")
+            instance.save()
+
+
+@shared_task
+def unsubscribe(subscription_id):
+    if subscription_id:
+        MicrosoftGraphAPI()._unsubscribe(subscription_id)
+
+
+@shared_task
+def verification_subscriptions(instance_id: int):
+    with transaction.atomic():
+        ms_subscriptions = [elt.get("id") for elt in MicrosoftGraphAPI().subscriptions()]
+        qs_subscriptions = Subscription.objects.filter(Q(id=instance_id) & Q(subscription_id__isnull=False))
+        qs_subscriptions.filter(~Q(subscription_id__in=ms_subscriptions)).update(is_enable=False)
+
+
+@shared_task
+def resubscribe_as_task(instance_id: int):
+    subscription = Subscription.objects.get(id=instance_id)
+    subscription.resubscribe()
+
+
+@receiver(post_save, sender=Subscription)
+def post_save_subscription(sender, instance, created, **kwargs):
+    if (created and instance.is_enable) or (instance.is_enable and not instance.subscription_id):
+        # Subscription to Call Event
+        if instance.type_resource == Subscription.TypeResource.CALLRECORD and not instance.expiration_date:
+            transaction.on_commit(
+                lambda: chain(
+                    subscribe.si(instance.id, "/communications/callRecords"),
+                    verification_subscriptions.si(instance.id),
+                ).apply_async()
+            )
+    elif not instance.is_enable and instance.subscription_id:
+        transaction.on_commit(
+            lambda: chain(
+                unsubscribe.si(instance.subscription_id), verification_subscriptions.si(instance.id)
+            ).apply_async()
+        )
+
+
+@receiver(post_delete, sender=Subscription)
+def post_delete_subscription(sender, instance, **kwargs):
+    unsubscribe.delay(instance.subscription_id)

wbintegrator_office365/models/tenant.py

@@ -0,0 +1,62 @@
+from django.conf import settings
+from django.db import models
+from wbcore.models import WBModel
+
+
+class TenantUser(WBModel):
+    class Meta:
+        verbose_name = "Tenant User"
+        verbose_name_plural = "Tenant Users"
+
+    tenant_id = models.CharField(max_length=255, null=True, blank=True, verbose_name="User tenant ID", default="")
+    display_name = models.CharField(max_length=255, null=True, blank=True, verbose_name="Display Name", default="")
+    tenant_organization_id = models.CharField(
+        max_length=255, null=True, blank=True, verbose_name="Organization tenant ID"
+    )
+    mail = models.CharField(max_length=255, null=True, blank=True, default="")
+    phone = models.CharField(max_length=255, null=True, blank=True, default="")
+    profile = models.ForeignKey(
+        "directory.Person",
+        related_name="tenant_user",
+        null=True,
+        blank=True,
+        on_delete=models.deletion.SET_NULL,
+        verbose_name="User",
+    )
+    is_internal_organization = models.BooleanField(null=True, blank=True)
+
+    def save(self, *args, **kwargs):
+        if self.tenant_organization_id and (org_id := getattr(settings, "WBINTEGRATOR_OFFICE365_TENANT_ID", None)):
+            self.is_internal_organization = self.tenant_organization_id == org_id
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        if self.profile:
+            name_tenant = f"{self.profile.computed_str}"
+        elif self.mail or self.display_name:
+            mail = self.mail if self.mail else self.id
+            name_tenant = f"{self.display_name}({mail})"
+        elif self.tenant_id:
+            name_tenant = f"{self.tenant_id}"
+        elif self.tenant_organization_id:
+            name_tenant = f"company-{self.tenant_organization_id}"
+        else:
+            name_tenant = f"{self.id}"
+        status = "Internal" if self.is_internal_organization else "External"
+        return f"{name_tenant} ({status})"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbintegrator_office365:tenantuser"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbintegrator_office365:tenantuserrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{profile_str}}({{id_str}})"

wbintegrator_office365/serializers.py

@@ -0,0 +1,266 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbintegrator_office365.models import (
+    CallEvent,
+    CallUser,
+    Event,
+    EventLog,
+    Subscription,
+    TenantUser,
+)
+
+
+class TenantUserRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:tenantuser-detail")
+    profile_str = wb_serializers.StringRelatedField(source="profile")
+    id_str = wb_serializers.CharField(source="id")
+
+    class Meta:
+        model = TenantUser
+        fields = ("id", "tenant_id", "profile_str", "id_str", "_detail")
+
+
+class SubscriptionRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:subscription-detail")
+
+    class Meta:
+        model = Subscription
+        fields = ("id", "subscription_id", "created", "_detail")
+
+
+class EventRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:event-detail")
+    id_str = wb_serializers.CharField(source="id")
+
+    class Meta:
+        model = Event
+        fields = ("id", "id_str", "uuid_event", "_detail")
+
+
+class CallUserRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:calluser-detail")
+    tenant_user_str = wb_serializers.StringRelatedField(source="tenant_user")
+    id_str = wb_serializers.CharField(source="id")
+
+    class Meta:
+        model = CallUser
+        fields = ("id", "tenant_user_str", "id_str", "_detail")
+
+
+class CallEventRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:callevent-detail")
+
+    class Meta:
+        model = CallEvent
+        fields = ("id", "_detail")
+
+
+class TenantUserModelSerializer(wb_serializers.ModelSerializer):
+    _profile = PersonRepresentationSerializer(source="profile")
+
+    class Meta:
+        model = TenantUser
+        fields = (
+            "id",
+            "tenant_id",
+            "display_name",
+            "mail",
+            "phone",
+            "profile",
+            "_profile",
+            "tenant_organization_id",
+            "is_internal_organization",
+        )
+
+
+class CallUserModelSerializer(wb_serializers.ModelSerializer):
+    _tenant_user = TenantUserRepresentationSerializer(source="tenant_user")
+
+    name_user = wb_serializers.CharField(read_only=True)
+    phone = wb_serializers.CharField(read_only=True)
+    mail = wb_serializers.CharField(read_only=True)
+
+    class Meta:
+        model = CallUser
+        fields = read_only_fields = (
+            "id",
+            "tenant_user",
+            "_tenant_user",
+            "is_guest",
+            "is_phone",
+            "acs_user",
+            "splool_user",
+            "encrypted",
+            "on_premises",
+            "acs_application_instance",
+            "spool_application_instance",
+            "application_instance",
+            "application",
+            "device",
+            "name_user",
+            "phone",
+            "mail",
+        )
+
+
+class SubscriptionModelSerializer(wb_serializers.ModelSerializer):
+    _tenant_user = TenantUserRepresentationSerializer(source="tenant_user")
+    id_str = wb_serializers.CharField(source="id")
+
+    class Meta:
+        model = Subscription
+        fields = read_only_fields = (
+            "id",
+            "id_str",
+            "subscription_id",
+            "change_type",
+            "notification_url",
+            "resource",
+            "expiration_date",
+            "application_id",
+            "creator_id",
+            "client_state",
+            "created",
+            "latest_supported_tls_version",
+            "notification_content_type",
+            "odata_context",
+            "encryption_certificate_id",
+            "encryption_certificate",
+            "include_resource_data",
+            "notification_query_options",
+            "tenant_user",
+            "_tenant_user",
+            "is_enable",
+            "type_resource",
+        )
+        read_only_fields = (
+            "id",
+            "subscription_id",
+            "change_type",
+            "notification_url",
+            "resource",
+            "expiration_date",
+            "application_id",
+            "creator_id",
+            "client_state",
+            "created",
+            "latest_supported_tls_version",
+            "notification_content_type",
+            "odata_context",
+            "encryption_certificate_id",
+            "encryption_certificate",
+            "include_resource_data",
+            "notification_query_options",
+            "tenant_user",
+            "is_enable",
+            "type_resource",
+        )
+
+
+class SubscriptionListModelSerializer(SubscriptionModelSerializer):
+    class Meta:
+        model = Subscription
+        fields = read_only_fields = (
+            "id",
+            "subscription_id",
+            "change_type",
+            "expiration_date",
+            "type_resource",
+            "resource",
+            "tenant_user",
+            "_tenant_user",
+            "is_enable",
+            "created",
+        )
+
+
+class EventModelSerializer(wb_serializers.ModelSerializer):
+    @wb_serializers.register_resource()
+    def register_history_resource(self, instance, request, user):
+        resources = {
+            "eventlog": reverse("wbintegrator_office365:event-eventlog-list", args=[instance.id], request=request),
+        }
+        return resources
+
+    id = wb_serializers.PrimaryKeyCharField()
+    id_str = wb_serializers.CharField(source="id")
+
+    _tenant_user = TenantUserRepresentationSerializer(source="tenant_user")
+
+    class Meta:
+        model = Event
+        fields = read_only_fields = (
+            "id",
+            "id_str",
+            "auto_inc_id",
+            "nb_received",
+            "type",
+            "subscription_id",
+            "change_type",
+            "resource",
+            "created",
+            "changed",
+            "tenant_user",
+            "_tenant_user",
+            "_additional_resources",
+            "id_event",
+            "uuid_event",
+            "is_handled",
+        )
+
+
+class EventLogRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _last_event = EventRepresentationSerializer(source="last_event")
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbintegrator_office365:eventlog-detail")
+
+    class Meta:
+        model = EventLog
+        fields = read_only_fields = ("id", "last_event", "_last_event", "order_received", "_detail")
+
+
+class EventLogModelSerializer(wb_serializers.ModelSerializer):
+    _last_event = EventRepresentationSerializer(source="last_event")
+
+    class Meta:
+        model = EventLog
+        fields = read_only_fields = (
+            "id",
+            "last_event",
+            "_last_event",
+            "change_type",
+            "order_received",
+            "created",
+            "changed",
+            "id_event",
+            "resource",
+            "is_handled",
+        )
+
+
+class CallEventModelSerializer(wb_serializers.ModelSerializer):
+    _event = EventRepresentationSerializer(source="event")
+    _organizer = CallUserRepresentationSerializer(source="organizer")
+    _participants = CallUserRepresentationSerializer(source="participants", many=True)
+    change_type = wb_serializers.CharField(required=False, read_only=True)
+
+    class Meta:
+        model = CallEvent
+        fields = read_only_fields = (
+            "id",
+            "event",
+            "_event",
+            "organizer",
+            "_organizer",
+            "type",
+            "change_type",
+            "start",
+            "end",
+            "last_modified",
+            "created",
+            "participants",
+            "_participants",
+            "is_internal_call",
+            "version",
+            "join_web_url",
+        )

wbintegrator_office365/tasks.py

@@ -0,0 +1,108 @@
+import math
+from datetime import date, timedelta
+
+from celery import shared_task
+from django.contrib.auth import get_user_model
+from django.db.models import Q
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbintegrator_office365.importer import MicrosoftGraphAPI
+from wbintegrator_office365.models.event import CallEvent
+from wbintegrator_office365.models.subscription import Subscription
+
+
+@shared_task
+def send_call_summary(to_emails: list, profile_ids: list, offset: int = 1):
+    for to_email in to_emails:
+        if (recipient := get_user_model().objects.filter(email=to_email).first()) and (
+            profiles := Person.objects.filter(id__in=profile_ids)
+        ):
+            _day = date.today() - timedelta(days=offset)
+
+            message = "<html><head><style> #summery_table tr:nth-child(even){background-color: #f2f2f2;}</style></head><body>"
+
+            for profile in profiles:
+                call_events = CallEvent.objects.filter(
+                    participants__tenant_user__profile__computed_str__icontains=profile.computed_str,
+                    start__date=_day,
+                    end__date=_day,
+                ).order_by("start")
+
+                message += f"<p> \
+                                <span><b> {profile.computed_str} </b></span><br/> \
+                                <span>Date: <b>{_day}</b> </span><br/> \
+                                <span>Total number of calls: <b>{call_events.count()}</b> </span> \
+                            </p>"
+                if call_events.count():
+                    message += "<table id='summery_table' style='border-collapse: collapse;'> \
+                                <tr style='color: white; background-color: #1868ae;'> \
+                                    <th style='border: 1px solid #ddd;padding: 10px 7px;' >Start</th> \
+                                    <th style='border: 1px solid #ddd;padding: 10px 7px;' >End</th> \
+                                    <th style='border: 1px solid #ddd;padding: 10px 7px;' >Duration (min)</th> \
+                                    <th style='border: 1px solid #ddd;padding: 10px 7px;' >Organized by</th> \
+                                    <th style='border: 1px solid #ddd;padding: 10px 7px;' >Participants</th> \
+                                </tr>"
+                    for call in call_events:
+                        participants = ""
+                        count = 0
+                        total_participants = call.participants.exclude(tenant_user__profile=profile).count()
+                        for participant in call.participants.exclude(tenant_user__profile=profile):
+                            count += 1
+                            participants += f"{participant.__str__()}"
+                            if count < total_participants:
+                                participants += ", "
+
+                        delta_in_minutes = divmod((call.end - call.start).total_seconds(), 60)
+                        _duration = f"{math.floor(delta_in_minutes[0])}:{math.floor(delta_in_minutes[1])}"
+                        message += f"<tr> \
+                                    <td style='border: 1px solid #ddd;padding: 2px;' >{call.start.astimezone().strftime('%Y-%m-%d %H:%M:%S')}</td> \
+                                    <td style='border: 1px solid #ddd;padding: 2px;' >{call.end.astimezone().strftime('%Y-%m-%d %H:%M:%S')}</td> \
+                                    <td style='border: 1px solid #ddd;padding: 0px;' text-align:center;><b>{_duration}</b></td> \
+                                    <td style='border: 1px solid #ddd;padding: 2px;' ><b>{call.organizer.__str__()}</b></td> \
+                                    <td style='border: 1px solid #ddd;padding: 2px;' >{participants}</td> \
+                                </tr>"
+                    message += "</table><br/>"
+
+            message += "</body></html>"
+
+        send_notification(
+            code="wbintegrator_office365.callevent.notify",
+            title=f"Call summary - {_day}",
+            body=message,
+            user=recipient,
+        )
+
+
+@shared_task
+def notify_no_active_call_record_subscription(to_email):
+    recipient = get_user_model().objects.filter(email=to_email)
+    ms_subscriptions = [elt.get("id") for elt in MicrosoftGraphAPI().subscriptions()]
+    qs_subscriptions = Subscription.objects.filter(
+        Q(is_enable=True) & Q(subscription_id__isnull=False) & Q(type_resource=Subscription.TypeResource.CALLRECORD)
+    )
+    enable_subcriptions = qs_subscriptions.filter(subscription_id__in=ms_subscriptions)
+    if recipient.exists() and (
+        len(ms_subscriptions) == 0 or (qs_subscriptions.count() > 0 and enable_subcriptions.count() == 0)
+    ):
+        _day = date.today()
+        send_notification(
+            code="wbintegrator_office365.callevent.notify",
+            title=f"No active Call Record subscriptions in Microsoft - {_day}",
+            body=f"""<p>There are currently no active Call record subscriptions in Microsoft, so we are no longer receiving calls, Please check</p>
+            <ul>
+                <li>Number of subscriptions on Microsoft: <b>{len(ms_subscriptions)}</b></li>
+                <li>Number of Call subscriptions: <b>{qs_subscriptions.count()}</b></li>
+                <li>Number of enabled calling subscriptions: <b>{enable_subcriptions.count()}</b></li>
+
+            </ul>
+            """,
+            user=recipient.first(),
+        )
+
+
+@shared_task
+def periodic_resubscribe_task():
+    for subscription in Subscription.objects.filter(
+        is_enable=True, type_resource=Subscription.TypeResource.CALLRECORD, subscription_id__isnull=False
+    ):
+        subscription.resubscribe()

wbintegrator_office365/tests/conftest.py

@@ -0,0 +1,28 @@
+from django.apps import apps
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.geography.tests.signals import (
+    app_pre_migration as app_pre_migration_geography,
+)
+from wbhuman_resources.tests.signals import app_pre_migration as app_pre_migration_hr
+from wbintegrator_office365.factories import (
+    CallEventFactory,
+    CallUserFactory,
+    EventFactory,
+    EventLogFactory,
+    SubscriptionFactory,
+    TenantUserFactory,
+)
+
+register(EventFactory)
+register(EventLogFactory)
+register(SubscriptionFactory)
+register(TenantUserFactory)
+register(CallUserFactory)
+register(CallEventFactory)
+register(UserFactory)
+
+pre_migrate.connect(app_pre_migration_hr, sender=apps.get_app_config("wbintegrator_office365"))
+pre_migrate.connect(app_pre_migration_geography, sender=apps.get_app_config("wbintegrator_office365"))