wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/agenda/models/calendar_item.py

@@ -0,0 +1,238 @@
+from contextlib import suppress
+
+from celery import shared_task
+from django.apps import apps
+from django.contrib.auth.backends import ModelBackend
+from django.contrib.postgres.fields import DateTimeRangeField
+from django.db import models, transaction
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+from ics import Event
+from wbcore.contrib.color.fields import ColorField
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.icons.models import IconField
+from wbcore.models import WBModel
+from wbcore.utils.itertools import get_inheriting_subclasses
+from wbcore.utils.models import DeleteToDisableMixin
+
+
+class CalendarItem(DeleteToDisableMixin, WBModel):
+    AUTOMATICALLY_CLEAN_SOFT_DELETED_OBJECTS = True
+
+    class Visibility(models.TextChoices):
+        PUBLIC = "PUBLIC", _("Public")
+        PRIVATE = "PRIVATE", _("Private")
+        CONFIDENTIAL = "CONFIDENTIAL", _("Confidential")
+
+    color = ColorField(
+        blank=True,
+        null=True,
+    )
+    entities = models.ManyToManyField(
+        to="directory.Entry", verbose_name=_("Entities"), related_name="calendar_entities"
+    )
+    entity_list = models.JSONField(blank=True, null=True)
+    icon = IconField(
+        max_length=128,
+        verbose_name=_("Icon"),
+        blank=True,
+        null=True,
+    )
+    visibility = models.CharField(
+        max_length=255,
+        choices=Visibility.choices,
+        verbose_name=_("Visibility"),
+        default=Visibility.PUBLIC,
+    )
+    item_type = models.CharField(max_length=255, verbose_name=_("Type"), blank=True, null=True)
+
+    period = DateTimeRangeField(
+        blank=True,
+        null=True,
+        # Translator: In this context, it is a period of time
+        verbose_name=_("Period"),
+    )
+    title = models.CharField(max_length=255, verbose_name=_("Title"))
+    conference_room = models.ForeignKey(
+        to="agenda.ConferenceRoom",
+        verbose_name=_("Conference Room"),
+        related_name="calendar_item",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+    )
+    all_day = models.BooleanField(
+        default=False, verbose_name=_("All Day"), help_text=_("Check this if the activity spans throughout the day")
+    )
+    is_cancelled = models.BooleanField(default=False, verbose_name=_("Is Cancelled"))
+    is_deletable = models.BooleanField(default=True, verbose_name=_("Is Deletable"))
+
+    def get_casted_calendar_item(self) -> models.Model:
+        """
+        Cast the calendar item into its child representative
+
+        Raises ValueError, AttributeError or LookupError on wrong item_type
+        """
+        model = apps.get_model(self.item_type)
+        return model.objects.get(pk=self.pk)
+
+    def get_color(self) -> str:
+        """Sets a default color value. This method should be overridden by subclasses.
+
+        Returns:
+            str: black as hex string
+        """
+
+        return "#000000"
+
+    def get_icon(self) -> str:
+        """Sets a default icon value. This method should be overridden by subclasses
+
+        Returns:
+            str: event icon string based on the icon backend
+        """
+
+        return WBIcon.EVENT.icon
+
+    @classmethod
+    def get_item_types_choices(cls) -> tuple[str, str]:
+        """
+        Iterate over all implementing classes and extract its item type
+        """
+        choices = []
+        for snd in get_inheriting_subclasses(CalendarItem):
+            if (
+                (_meta := getattr(snd, "_meta", None))
+                and hasattr(snd, "get_item_type")
+                and callable(snd.get_item_type)
+            ):
+                choices.append((snd.get_item_type(), _meta.verbose_name))
+        return choices
+
+    @classmethod
+    def get_item_type(cls) -> str:
+        # Problems with the app label can occur with nested apps. To prevent these cases,
+        # we must ensure that only the last part of the app label is used.
+        app_label: str = cls._meta.app_label.split(".")[-1]
+        return f"{app_label}.{cls.__name__}"
+
+    def __str__(self):
+        return self.title
+
+    def save(self, *args, **kwargs):
+        if not self.item_type:
+            self.item_type = self.get_item_type()
+
+        self.color = self.get_color()
+        self.icon = self.get_icon()
+        super().save(*args, **kwargs)
+
+    @property
+    def endpoint_basename(self) -> str | None:
+        with suppress(ValueError, AttributeError, LookupError):
+            return apps.get_model(self.item_type).get_endpoint_basename()
+
+    def to_ics(self, start=None, end=None):
+        """
+        Convert calendar item model to ICS event
+
+        Arguments:
+            start {datetime.date} -- Start calendar item time if self.start is None
+            end {datetime.date} -- End calendar item time if self.end is None
+        Returns:
+            Event -- The calendar item as ICS event
+        """
+        e = Event()
+        if self.period:
+            if not start:
+                start = self.period.lower  # type: ignore
+            if not end:
+                end = self.period.upper  # type: ignore
+        if (start and end) and (start < end):
+            e.name = self.title
+            e.begin = start
+            e.end = end
+
+            _id = f"workbench-{self.id}-{start}-{end}"
+            e.uid = _id.replace(" ", "_")
+            with suppress(ValueError, AttributeError, LookupError):
+                casted_calendar_item = self.get_casted_calendar_item()
+                if hasattr(casted_calendar_item, "get_extra_ics_kwargs") and callable(
+                    casted_calendar_item.get_extra_ics_kwargs
+                ):
+                    for k, v in casted_calendar_item.get_extra_ics_kwargs():
+                        setattr(e, k, v)
+
+                return e
+        else:
+            return None
+
+    def can_delete(self, user):
+        try:
+            return self.get_casted_calendar_item().is_deletable and (
+                self.entities.filter(id=user.profile.id).exists()
+                or self.has_user_administrate_permission(user, include_superusers=True)
+            )
+        except (ValueError, AttributeError, LookupError):
+            return False
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:agenda:calendaritem"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:agenda:calendaritemrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{title}}"
+
+    @classmethod
+    def has_user_administrate_permission(cls, user, include_superusers: bool = False) -> bool:
+        return user in ModelBackend().with_perm(
+            "agenda.administrate_confidential_items", include_superusers=include_superusers
+        )
+
+    @property
+    def duration(self):
+        if self.period.lower and self.period.upper:
+            return self.period.upper - self.period.lower
+
+    class Meta:
+        verbose_name = _("Calendar Item")
+        verbose_name_plural = _("Calendar Items")
+        permissions = [
+            ("administrate_confidential_items", "Can administrate calendar items"),
+        ]
+        indexes = [models.Index(fields=["period"])]
+
+
+@receiver(models.signals.m2m_changed, sender=CalendarItem.entities.through)
+def m2m_entities_changed(sender, instance, action, pk_set, **kwargs):
+    if action in ["post_add", "post_remove", "post_clear"]:
+        transaction.on_commit(set_entity_list.s(instance.id).delay)
+
+
+@shared_task
+def set_entity_list(calendar_item_id: int):
+    frontend_list = []
+    with suppress(
+        CalendarItem.DoesNotExist
+    ):  # for sanitization reason, we catch this error in case of db slowness. It doesn't really matter as this is computed frequently.
+        instance = CalendarItem.objects.get(id=calendar_item_id)
+        for entity in instance.entities.exclude(entry_type="Company"):
+            person = entity.get_casted_entry()
+            frontend_list.append(
+                {
+                    "id": person.id,
+                    "label": person.initials,
+                    "tooltip": person.computed_str,
+                }
+            )
+        instance.entity_list = frontend_list
+        instance.save()

wbcore/contrib/agenda/models/conference_room.py

@@ -0,0 +1,95 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.agenda.typings import ConferenceRoom as ConferenceRoomDTO
+from wbcore.models import WBModel
+
+
+class Building(WBModel):
+    name = models.CharField(max_length=255, verbose_name=_("Name"))
+    address = models.ForeignKey(
+        on_delete=models.SET_NULL,
+        to="directory.AddressContact",
+        verbose_name=_("Address"),
+        related_name="conference_room_building",
+        null=True,
+        blank=True,
+    )
+
+    def __str__(self) -> str:
+        return f"{self.name}"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:agenda:building"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:agenda:buildingrepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{name}}"
+
+    class Meta:
+        verbose_name = _("Building")
+        constraints = [
+            models.UniqueConstraint(
+                fields=["name", "address"],
+                name="unique_building",
+            ),
+        ]
+
+
+class ConferenceRoom(WBModel):
+    name = models.CharField(max_length=255, verbose_name=_("Name"))
+    email = models.EmailField(verbose_name=_("Email Address"), unique=True)
+    building = models.ForeignKey(
+        on_delete=models.CASCADE,
+        to=Building,
+        verbose_name=_("Building"),
+        related_name="conference_room",
+    )
+    capacity = models.PositiveIntegerField(verbose_name=_("Capacity"), null=True, blank=True)
+    is_videoconference_capable = models.BooleanField(verbose_name=_("Capable of Videoconferencing"), default=True)
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.building.name})"
+
+    def _build_dto(self):
+        return ConferenceRoomDTO(
+            name=self.name,
+            email=self.email,
+            name_building=self.building.name,
+            capacity=self.capacity,
+            is_videoconference_capable=self.is_videoconference_capable,
+            id=self.id,
+        )
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:agenda:conferenceroom"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:agenda:conferenceroomrepresentation-list"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{name}} ({{_building.name}})"
+
+    class Meta:
+        verbose_name = _("Conference Room")
+        constraints = [
+            models.UniqueConstraint(
+                fields=["name", "building"],
+                name="unique_conference_room",
+            ),
+        ]

wbcore/contrib/agenda/release_notes/1_0_0.md

@@ -0,0 +1,13 @@
+Date: 2023-04-26
+Module: Agenda
+Summary: Initial Release Note
+Version: 1.0.0
+
+## New Features
+- Bootstrap module versioning
+
+## Enhancements
+./.
+
+## Bugfixes
+./.

wbcore/contrib/agenda/serializers/__init__.py

@@ -0,0 +1,10 @@
+from .calendar_item import (
+    CalendarItemModelSerializer,
+    CalendarItemRepresentationSerializer,
+)
+from .conference_room import (
+    BuildingModelSerializer,
+    BuildingRepresentationSerializer,
+    ConferenceRoomModelSerializer,
+    ConferenceRoomRepresentationSerializer,
+)

wbcore/contrib/agenda/serializers/calendar_item.py

@@ -0,0 +1,76 @@
+from collections import OrderedDict
+
+from django.utils.translation import gettext as _
+from rest_framework.reverse import NoReverseMatch, reverse
+from wbcore import serializers
+from wbcore.contrib.agenda.models import CalendarItem
+
+
+class CalendarItemRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.SerializerMethodField()
+
+    def get__detail(self, obj) -> str:
+        try:
+            return reverse(f"{obj.endpoint_basename}-detail", args=[obj.id], request=self.context["request"])
+        except (NoReverseMatch, KeyError):
+            return ""
+
+    class Meta:
+        model = CalendarItem
+        fields = (
+            "id",
+            "title",
+            "_detail",
+        )
+
+
+class CalendarItemModelSerializer(serializers.ModelSerializer):
+    activity_id = serializers.CharField()
+    endpoint = serializers.SerializerMethodField()
+    is_confidential = serializers.BooleanField(default=False, read_only=True)
+    is_draggable = serializers.BooleanField(default=False, read_only=True)
+    is_private = serializers.BooleanField(default=False, read_only=True)
+
+    def get_endpoint(self, obj):
+        try:
+            return reverse(f"{obj.endpoint_basename}-detail", args=[obj.id], request=self.context["request"])
+        except (NoReverseMatch, KeyError):
+            return ""
+
+    def to_representation(self, instance: CalendarItem) -> OrderedDict:
+        representation = super().to_representation(instance)
+
+        is_private: bool
+        if (is_private := representation.get("is_private", False)) or representation.get("is_confidential", False):
+            item_type = instance.item_type.split(".")[1] if instance.item_type else _("Item")
+            representation["title"] = (
+                _("Private {}").format(item_type) if is_private else _("Confidential {}").format(item_type)
+            )
+            if not is_private:
+                representation["_entities"] = ""
+                representation["entities"] = ""
+                representation["entity_list"] = ""
+
+        return representation
+
+    class Meta:
+        model = CalendarItem
+        read_only_fields = ("is_cancelled",)
+        fields = (
+            "id",
+            "title",
+            "entities",
+            "all_day",
+            "activity_id",
+            "color",
+            "endpoint",
+            "entity_list",
+            "icon",
+            "is_cancelled",
+            "is_confidential",
+            "is_draggable",
+            "is_private",
+            "period",
+            "is_deletable",
+        )
+        read_only_fields = ("endpoint",)

wbcore/contrib/agenda/serializers/conference_room.py

@@ -0,0 +1,98 @@
+from django.forms import ValidationError
+from django.utils.translation import gettext_lazy as _
+from wbcore import serializers
+from wbcore.contrib.agenda.models import Building, ConferenceRoom
+from wbcore.contrib.directory.serializers.contacts import (
+    AddressContactRepresentationSerializer,
+)
+
+
+class BuildingRepresentationSerializer(serializers.RepresentationSerializer):
+    endpoint = "wbcore:agenda:buildingrepresentation-list"
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:agenda:building-detail")
+    _address = AddressContactRepresentationSerializer(source="address")
+
+    class Meta:
+        model = Building
+        fields = (
+            "id",
+            "name",
+            "address",
+            "_address",
+            "_detail",
+        )
+
+
+class ConferenceRoomRepresentationSerializer(serializers.RepresentationSerializer):
+    endpoint = "wbcore:agenda:conferenceroomrepresentation-list"
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:agenda:conferenceroom-detail")
+    _building = BuildingRepresentationSerializer(source="building")
+
+    class Meta:
+        model = ConferenceRoom
+        fields = (
+            "id",
+            "name",
+            "building",
+            "_building",
+            "_detail",
+        )
+
+
+class BuildingModelSerializer(serializers.ModelSerializer):
+    _address = AddressContactRepresentationSerializer(source="address")
+
+    class Meta:
+        model = Building
+        fields = (
+            "id",
+            "name",
+            "address",
+            "_address",
+        )
+
+    def validate(self, data):
+        name = data.get("name", None)
+        address = data.get("address", None)
+
+        if address:
+            building = Building.objects.filter(name=name, address=address)
+        else:
+            building = Building.objects.filter(name=name)
+        if obj := self.instance:
+            building = building.exclude(id=obj.id)
+        if building.exists():
+            raise ValidationError({"name": _("A building with this name and address already exists.")})
+        return data
+
+
+class ConferenceRoomModelSerializer(serializers.ModelSerializer):
+    _building = BuildingRepresentationSerializer(source="building")
+
+    class Meta:
+        model = ConferenceRoom
+        fields = (
+            "id",
+            "name",
+            "email",
+            "building",
+            "_building",
+            "capacity",
+            "is_videoconference_capable",
+        )
+
+    def validate(self, data):
+        name = data.get("name", None)
+        building = data.get("building", None)
+        email = data.get("email", None)
+
+        mail_dupl = ConferenceRoom.objects.filter(email=email)
+        conference_room_dupl = ConferenceRoom.objects.filter(name=name, building=building)
+        if obj := self.instance:
+            mail_dupl = mail_dupl.exclude(id=obj.id)
+            conference_room_dupl = conference_room_dupl.exclude(id=obj.id)
+        if mail_dupl.exists():
+            raise ValidationError({("email"): _("A conference room with this email address already exists.")})
+        if conference_room_dupl.exists():
+            raise ValidationError({("name"): _("A conference room with this name already exists in this building.")})
+        return data

wbcore/contrib/agenda/signals.py

@@ -0,0 +1,8 @@
+from django.db.models.signals import ModelSignal
+
+draggable_calendar_item_ids = (
+    ModelSignal()
+)  # Signal called to gather the list of calendar items that are considered draggable.
+
+complete_post_save = ModelSignal()
+complete_post_delete = ModelSignal()

wbcore/contrib/agenda/tests/conftest.py

@@ -0,0 +1,14 @@
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.directory.factories import EntryFactory, PersonFactory
+from wbcore.tests.conftest import *
+
+from ..factories import BuildingFactory, CalendarItemFactory, ConferenceRoomFactory
+from .signals import *
+
+register(CalendarItemFactory)
+register(BuildingFactory)
+register(EntryFactory)
+register(PersonFactory)
+register(UserFactory)
+register(ConferenceRoomFactory)

wbcore/contrib/agenda/tests/signals.py

@@ -0,0 +1,16 @@
+from django.dispatch import receiver
+from wbcore.test.signals import get_custom_factory
+
+from ..factories import CalendarItemFactory
+from ..viewsets import (
+    CalendarItemViewSet,
+    InfiniteCalendarItemViewSet,
+    OwnCalendarItemViewSet,
+)
+
+
+@receiver(get_custom_factory, sender=CalendarItemViewSet)
+@receiver(get_custom_factory, sender=InfiniteCalendarItemViewSet)
+@receiver(get_custom_factory, sender=OwnCalendarItemViewSet)
+def receive_factory_employee(sender, *args, **kwargs):
+    return CalendarItemFactory

wbcore/contrib/agenda/tests/test_models.py

@@ -0,0 +1,34 @@
+import pytest
+from django.contrib.auth.models import Permission
+
+
+@pytest.mark.django_db
+class TestCalendarItemTest:
+    def test_to_ics(self, calendar_item_factory):
+        calendar_item1 = calendar_item_factory()
+        assert calendar_item1.to_ics(calendar_item1.period.upper, calendar_item1.period.lower) is None
+        calendar_item2 = calendar_item_factory()
+        assert calendar_item2.to_ics(calendar_item1.period.lower, calendar_item1.period.upper)
+
+    def test_get_item_type(self, calendar_item_factory):
+        calendar_item = calendar_item_factory()
+        assert calendar_item.get_item_type() == "agenda.CalendarItem"
+
+    @pytest.mark.parametrize("calendar_item__is_deletable", [True, False])
+    def test_cannot_delete_calendar_item(self, calendar_item, user):
+        assert not calendar_item.can_delete(
+            user
+        )  # as user is not a manger nor among the entities, he cannot delete the event
+
+    @pytest.mark.parametrize("calendar_item__is_deletable", [True, False])
+    def test_can_manager_delete_event(self, calendar_item, user):
+        permission = Permission.objects.get(
+            content_type__app_label="agenda", codename="administrate_confidential_items"
+        )
+        user.user_permissions.add(permission)
+        assert calendar_item.can_delete(user) == calendar_item.is_deletable
+
+    @pytest.mark.parametrize("calendar_item__is_deletable", [True, False])
+    def test_can_participants_delete_event(self, calendar_item, user):
+        calendar_item.entities.add(user.profile.id)
+        assert calendar_item.can_delete(user) == calendar_item.is_deletable