wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/agenda/tests/test_viewsets.py

@@ -0,0 +1,171 @@
+import pytest
+from django.contrib.auth.models import Permission
+from rest_framework import status
+from rest_framework.reverse import reverse
+from rest_framework.test import APIClient, APIRequestFactory
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.agenda.viewsets import CalendarItemViewSet
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.test.utils import get_kwargs, get_or_create_superuser
+
+from ..factories import CalendarItemFactory
+
+
+@pytest.mark.django_db
+class TestCalendarItemViewSet:
+    api_factory = APIRequestFactory()
+
+    def test_activity_is_draggable(self, calendar_item_factory, user_factory):
+        calendar_item = calendar_item_factory()
+        request = self.api_factory.get("")
+        request.user = user_factory(is_active=True, is_superuser=True)
+        view = CalendarItemViewSet.as_view({"get": "retrieve"})
+        response = view(request, pk=calendar_item.id).render()
+        assert response.data["instance"]["is_draggable"] is False
+
+    # =================================================================================================================
+    #                                            TESTING PRIVATE CALENDAR ITEMS
+    # =================================================================================================================
+
+    def test_entity_can_see_private_item(self, calendar_item_factory, user_factory):
+        user = user_factory(is_active=True, is_superuser=True)
+        activity = calendar_item_factory(entities=[user.profile], visibility=CalendarItem.Visibility.PRIVATE)
+        request = self.api_factory.get("")
+        request.user = user
+        view = CalendarItemViewSet.as_view({"get": "list"})
+        response = view(request).render()
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["results"]
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["id"] == activity.id
+        assert response.data["results"][0]["is_private"] is False
+        assert response.data["results"][0]["title"] == activity.title
+
+    @pytest.mark.parametrize("mvs", [CalendarItemViewSet])
+    def test_random_cannot_see_private_item(self, mvs, calendar_item_factory, user_factory):
+        user = user_factory(is_active=True, is_superuser=True)
+        item = calendar_item_factory(visibility=CalendarItem.Visibility.PRIVATE)
+        request = self.api_factory.get("")
+        request.user = user
+        view = mvs.as_view({"get": "list"})
+        response = view(request).render()
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["results"]
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["id"] == item.id
+        assert response.data["results"][0]["is_private"] is True
+        assert response.data["results"][0]["title"] == "Private CalendarItem"
+
+    # =================================================================================================================
+    #                                            TESTING CONFIDENTIAL CALENDAR ITEMS
+    # =================================================================================================================
+
+    @pytest.mark.parametrize("mvs", [CalendarItemViewSet])
+    def test_manager_can_see_confidential_item(self, mvs, calendar_item_factory, user_factory):
+        user = user_factory(is_active=True, is_superuser=True)
+        permission = Permission.objects.get(
+            content_type__app_label="agenda", codename="administrate_confidential_items"
+        )
+        user.user_permissions.add(permission)
+        item = calendar_item_factory(visibility=CalendarItem.Visibility.CONFIDENTIAL)
+        request = self.api_factory.get("")
+        request.user = user
+        view = mvs.as_view({"get": "list"})
+        response = view(request).render()
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["results"]
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["id"] == item.id
+        assert response.data["results"][0]["is_confidential"] is False
+        assert response.data["results"][0]["title"] == item.title
+
+    @pytest.mark.parametrize("mvs", [CalendarItemViewSet])
+    def test_random_cannot_see_confidential_item(self, mvs, calendar_item_factory, user_factory):
+        user = user_factory(is_active=True, is_superuser=True)
+        item = calendar_item_factory(visibility=CalendarItem.Visibility.CONFIDENTIAL)
+        request = self.api_factory.get("")
+        request.user = user
+        view = mvs.as_view({"get": "list"})
+        response = view(request).render()
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["results"]
+        assert len(response.data["results"]) == 1
+        assert response.data["results"][0]["id"] == item.id
+        assert response.data["results"][0]["is_confidential"] is True
+        assert response.data["results"][0]["title"] == "Confidential CalendarItem"
+
+
+@pytest.mark.django_db
+class TestSpecificsInfiniteViewsets:
+    @pytest.mark.parametrize(
+        "mvs, factory",
+        [
+            (CalendarItemViewSet, CalendarItemFactory),
+        ],
+    )
+    def test_option_request(self, mvs, factory, entry):
+        request = APIRequestFactory().options("")
+        request.user = get_or_create_superuser()
+        obj = factory(entities=(entry,))
+        request.GET = request.GET.copy()
+        request.GET["date_gte"] = str(obj.period.lower.date())
+        kwargs = {}
+        mvs.request = request
+        vs = mvs.as_view({"options": "options"})
+        kwargs = get_kwargs(obj, mvs, request=request)
+        response = vs(request, **kwargs).render()
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+
+    @pytest.mark.parametrize(
+        "mvs, factory",
+        [
+            (CalendarItemViewSet, CalendarItemFactory),
+        ],
+    )
+    def test_viewsets(self, mvs, factory, entry):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        obj = factory(entities=(entry,))
+        request.GET = request.GET.copy()
+        request.GET["date_gte"] = str(obj.period.lower.date())
+        kwargs = {}
+        mvs.request = request
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request, **kwargs).render()
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+
+    @pytest.mark.parametrize(
+        "mvs, factory",
+        [
+            (CalendarItemViewSet, CalendarItemFactory),
+        ],
+    )
+    def test_viewsets_without_date_gte(self, mvs, factory, entry):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        factory(entities=(entry,))
+        request.GET = request.GET.copy()
+        request.GET["date_gte"] = None
+        kwargs = {}
+        mvs.request = request
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request, **kwargs).render()
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+
+    def test_get_ics(self, calendar_item_factory):
+        client = APIClient()
+        user = UserFactory(is_active=True, is_superuser=True)
+        calendar_item_factory(
+            entities=(user.profile,),
+        )
+
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:agenda:get_ics", args=[]))
+        assert response.status_code == status.HTTP_200_OK

wbcore/contrib/agenda/tests/tests.py

@@ -0,0 +1,25 @@
+import pytest
+from wbcore.contrib.agenda.typings import ConferenceRoom as ConferenceRoomDTO
+
+
+@pytest.mark.django_db
+class TestDTO:
+    @pytest.mark.parametrize(
+        "id, name, email",
+        [
+            (None, None, None),
+            (None, "test", None),
+            (None, "test", "test@test.com"),
+            (1, None, None),
+            (1, "test", None),
+            (1, "test", "test@test.com"),
+        ],
+    )
+    def test_comparison(self, id, name, email):
+        conf_room1 = ConferenceRoomDTO(1, "test", "test@test.com")
+        conf_room2 = ConferenceRoomDTO(id=id, name=name, email=email)
+        if (conf_room1.id == conf_room2.id is not None) or (conf_room1.email == conf_room2.email is not None):
+            assert conf_room1 == conf_room2
+        else:
+            assert conf_room1 != conf_room2
+        assert conf_room2 is not None

wbcore/contrib/agenda/typings.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ConferenceRoom:
+    name: str
+    email: str
+    name_building: str = None
+    capacity: int = None
+    is_videoconference_capable: bool = True
+    id: str = None
+
+    def __eq__(self, other):
+        if other and (
+            (self.id and other.id and self.id == other.id)
+            or (self.email and other.email and self.email == other.email)
+        ):
+            return True
+        return super().__eq__(other)

wbcore/contrib/agenda/urls.py

@@ -0,0 +1,25 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from . import viewsets
+
+router = WBCoreRouter()
+router.register(r"calendaritem", viewsets.InfiniteCalendarItemViewSet, basename="calendaritem")
+router.register(
+    r"calendaritemrepresentation", viewsets.CalendarItemRepresentationViewSet, basename="calendaritemrepresentation"
+)
+router.register(r"owncalendar", viewsets.OwnCalendarItemViewSet, basename="owncalendar")
+router.register(
+    r"conferenceroomrepresentation",
+    viewsets.ConferenceRoomRepresentationViewSet,
+    basename="conferenceroomrepresentation",
+)
+router.register(r"conferenceroom", viewsets.ConferenceRoomModelViewSet, basename="conferenceroom")
+router.register(r"buildingrepresentation", viewsets.BuildingRepresentationViewSet, basename="buildingrepresentation")
+router.register(r"building", viewsets.BuildingModelViewSet, basename="building")
+
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("ics/", viewsets.get_ics, name="get_ics"),
+]

wbcore/contrib/agenda/viewsets/__init__.py

@@ -0,0 +1,13 @@
+from .calendar_items import (
+    CalendarItemRepresentationViewSet,
+    CalendarItemViewSet,
+    InfiniteCalendarItemViewSet,
+    OwnCalendarItemViewSet,
+    get_ics,
+)
+from .conference_room import (
+    BuildingModelViewSet,
+    BuildingRepresentationViewSet,
+    ConferenceRoomModelViewSet,
+    ConferenceRoomRepresentationViewSet,
+)

wbcore/contrib/agenda/viewsets/buttons/__init__.py

@@ -0,0 +1 @@
+from .conference_room import BuildingButtonConfig

wbcore/contrib/agenda/viewsets/buttons/conference_room.py

@@ -0,0 +1,20 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class BuildingButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        if not self.view.kwargs.get("pk", None):
+            base_url = reverse("wbcore:directory:addresscontact-list", args=[], request=self.request)
+
+            return {
+                bt.WidgetButton(
+                    endpoint=base_url,
+                    label=_("New Address"),
+                    icon="add_location",
+                    new_mode=True,
+                )
+            }
+        return {}

wbcore/contrib/agenda/viewsets/calendar_items.py

@@ -0,0 +1,168 @@
+from datetime import timedelta
+from io import StringIO
+
+from django.db.models import Case, Q, QuerySet, Value, When
+from django.http import HttpResponse
+from django.utils import timezone
+from django.utils.functional import cached_property
+from ics import Calendar
+from psycopg.types.range import TimestamptzRange
+from rest_framework import status
+from rest_framework.decorators import (
+    api_view,
+    authentication_classes,
+    permission_classes,
+)
+from rest_framework.permissions import AllowAny
+from wbcore import viewsets
+from wbcore.contrib.authentication.authentication import QueryTokenAuthentication
+from wbcore.contrib.directory.models import Person
+from wbcore.utils.itertools import get_inheriting_subclasses
+
+from ..filters import CalendarItemFilter
+from ..models import CalendarItem
+from ..serializers import (
+    CalendarItemModelSerializer,
+    CalendarItemRepresentationSerializer,
+)
+from ..signals import draggable_calendar_item_ids
+from .display import CalendarItemDisplay
+from .endpoints import CalendarItemEndpointConfig
+from .titles import CalendarItemTitleConfig
+
+
+class CalendarItemRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = CalendarItem.objects.all()
+    serializer_class = CalendarItemRepresentationSerializer
+
+
+class CalendarItemMetaClass(type(viewsets.ModelViewSet)):
+    def __new__(metacls, cls, bases, classdict, **kwds):
+        _class = super().__new__(metacls, cls, bases, classdict, **kwds)
+        dependant_identifiers = []
+        for subclass in get_inheriting_subclasses(_class):
+            if identifier := getattr(subclass, "IDENTIFIER", None):
+                dependant_identifiers.append(identifier)
+        setattr(_class, "DEPENDANT_IDENTIFIERS", dependant_identifiers)
+        return _class
+
+
+class CalendarItemViewSet(viewsets.ModelViewSet, metaclass=CalendarItemMetaClass):
+    display_config_class = CalendarItemDisplay
+    endpoint_config_class = CalendarItemEndpointConfig
+    filterset_class = CalendarItemFilter
+    search_fields = ("title",)
+    serializer_class = CalendarItemModelSerializer
+    title_config_class = CalendarItemTitleConfig
+    ordering = ("period__startswith", "id")
+    queryset = CalendarItem.objects.all()
+
+    @cached_property
+    def request_profile(self):
+        return getattr(self.request.user, "profile", None)
+
+    @cached_property
+    def draggable_calendar_item_ids(self) -> QuerySet[CalendarItem]:
+        """
+        Property to store the unioned queryset of draggable calendar items. Each module inheriting from CalendarItem are expected to define the signal receiver
+        """
+        qs = CalendarItem.objects.none()
+        for tmp, union_qs in draggable_calendar_item_ids.send(CalendarItem, request=self.request):
+            qs = qs.union(union_qs)
+        return qs
+
+    @cached_property
+    def allowed_privates_calendar_item_ids(self) -> list[int]:
+        if self.request_profile:
+            return list(
+                CalendarItem.objects.filter(
+                    entities=self.request_profile, visibility=CalendarItem.Visibility.PRIVATE
+                ).values_list("id", flat=True)
+            )
+        return list()
+
+    @cached_property
+    def has_user_administrate_permission(self) -> bool:
+        return CalendarItem.has_user_administrate_permission(self.request.user)
+
+    def get_queryset(self):
+        qs = (
+            super()
+            .get_queryset()
+            .annotate(
+                is_draggable=Case(When(id__in=self.draggable_calendar_item_ids, then=True), default=False),
+                is_private=Case(
+                    When(
+                        Q(visibility=CalendarItem.Visibility.PRIVATE)
+                        & ~Q(id__in=self.allowed_privates_calendar_item_ids),
+                        then=True,
+                    ),
+                    default=False,
+                ),
+            )
+        )
+        if self.has_user_administrate_permission:
+            qs = qs.annotate(is_confidential=Value(False))
+        else:
+            qs = qs.annotate(
+                is_confidential=Case(
+                    When(visibility=CalendarItem.Visibility.CONFIDENTIAL, then=True),
+                    default=False,
+                )
+            )
+        return qs.prefetch_related("entities")
+
+
+class InfiniteCalendarItemViewSet(CalendarItemViewSet):
+    pagination_class = None
+
+
+class OwnCalendarItemViewSet(CalendarItemViewSet):
+    def get_queryset(self):
+        if self.request_profile:
+            return super().get_queryset().filter(is_cancelled=False, entities=self.request_profile)
+        return super().get_queryset().none()
+
+
+@api_view(["GET"])
+@permission_classes([AllowAny])
+@authentication_classes([QueryTokenAuthentication])
+def get_ics(request):
+    """
+    API Calendar ICS request endpoint
+
+    Return the ICS formatted calendar for the user with token
+    """
+    conference_room = request.GET.get("conference_room", "False") == "True"
+    team = request.GET.get("team", "False") == "True"
+    only_today = request.GET.get("only_today", "False") == "True"
+    if profile := getattr(request.user, "profile", None):
+        qs = CalendarItem.objects.exclude(is_cancelled=False)
+        if conference_room:
+            qs = qs.filter(conference_room=True).distinct()
+        elif team:
+            qs = CalendarItem.objects.filter(entities__in=Person.objects.filter_only_internal().values("id"))
+        else:
+            qs = CalendarItem.objects.filter(entities__id=profile.id)
+        if only_today:
+            minimum_date = timezone.now().date()
+            maximum_date = minimum_date + timedelta(days=1)
+        else:
+            minimum_date = timezone.now() - timedelta(days=30)
+            maximum_date = timezone.now() + timedelta(days=30)
+        min_max_range = TimestamptzRange(minimum_date, maximum_date)
+        gen = qs.filter(period__contained_by=min_max_range)
+
+        iCal = Calendar()
+        for occurence in gen:
+            start = occurence.period.lower
+            end = occurence.period.upper
+            activity = occurence
+            event = activity.to_ics(start, end)
+            if event:
+                iCal.events.add(event)
+        data = StringIO(str(iCal))
+        response = HttpResponse(data, content_type="text/calendar")
+        response["Content-Disposition"] = f'attachment; filename="{profile.computed_str}.ics"'
+        return response
+    return HttpResponse(status=status.HTTP_400_BAD_REQUEST)

wbcore/contrib/agenda/viewsets/conference_room.py

@@ -0,0 +1,48 @@
+from wbcore import viewsets
+from wbcore.contrib.agenda.filters import BuildingFilter, ConferenceRoomFilter
+from wbcore.contrib.agenda.models import Building, ConferenceRoom
+from wbcore.contrib.agenda.serializers import (
+    BuildingModelSerializer,
+    BuildingRepresentationSerializer,
+    ConferenceRoomModelSerializer,
+    ConferenceRoomRepresentationSerializer,
+)
+
+from .buttons import BuildingButtonConfig
+from .display import BuildingDisplay, ConferenceRoomDisplay
+from .titles import BuildingTitleConfig, ConferenceRoomTitleConfig
+
+
+class BuildingModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "agenda/markdown/documentation/building.md"
+    queryset = Building.objects.all()
+    serializer_class = BuildingModelSerializer
+    display_config_class = BuildingDisplay
+    title_config_class = BuildingTitleConfig
+    search_fields = ("name",)
+    ordering_fields = ordering = ("name",)
+    button_config_class = BuildingButtonConfig
+    filterset_class = BuildingFilter
+
+
+class BuildingRepresentationViewSet(viewsets.RepresentationViewSet):
+    serializer_class = BuildingRepresentationSerializer
+    search_fields = ("name",)
+    queryset = Building.objects.all()
+
+
+class ConferenceRoomModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "agenda/markdown/documentation/conferenceroom.md"
+    queryset = ConferenceRoom.objects.all()
+    serializer_class = ConferenceRoomModelSerializer
+    display_config_class = ConferenceRoomDisplay
+    title_config_class = ConferenceRoomTitleConfig
+    search_fields = ("name",)
+    ordering_fields = ordering = ("name",)
+    filterset_class = ConferenceRoomFilter
+
+
+class ConferenceRoomRepresentationViewSet(viewsets.RepresentationViewSet):
+    serializer_class = ConferenceRoomRepresentationSerializer
+    search_fields = ("name",)
+    queryset = ConferenceRoom.objects.all()

wbcore/contrib/agenda/viewsets/display/__init__.py

@@ -0,0 +1,2 @@
+from .calendar_items import CalendarItemDisplay
+from .conference_room import BuildingDisplay, ConferenceRoomDisplay

wbcore/contrib/agenda/viewsets/display/calendar_items.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CalendarItemDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.Calendar(
+            title="title",
+            period="period",
+            endpoint="endpoint",
+            all_day="all_day",
+            color="color",
+            icon="icon",
+            entities="entity_list",
+        )

wbcore/contrib/agenda/viewsets/display/conference_room.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class BuildingDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="name", label=_("Name")),
+                dp.Field(key="address", label=_("Address")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["name", "address"]])
+
+
+class ConferenceRoomDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="name", label=_("Name")),
+                dp.Field(key="email", label=_("E-Mail-Address")),
+                dp.Field(key="building", label=_("Building")),
+                dp.Field(key="capacity", label=_("Capacity")),
+                dp.Field(key="is_videoconference_capable", label=_("Capable of Videoconferencing")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [[repeat_field(2, "name"), "email"], ["building", "capacity", "is_videoconference_capable"]]
+        )

wbcore/contrib/agenda/viewsets/endpoints/__init__.py

@@ -0,0 +1 @@
+from .calendar_items import CalendarItemEndpointConfig

wbcore/contrib/agenda/viewsets/endpoints/calendar_items.py

@@ -0,0 +1,18 @@
+from django.conf import settings
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class CalendarItemEndpointConfig(EndpointViewConfig):
+    def _get_instance_endpoint(self, **kwargs):
+        return "{{endpoint}}"
+
+    def get_create_endpoint(self, **kwargs):
+        return f"{reverse(settings.DEFAULT_CREATE_ENDPOINT_BASENAME, args=[], request=self.request)}?participants={self.request.user.profile.id}&new_mode=True"
+
+    def get_delete_endpoint(self, **kwargs):
+        try:
+            if self.view.get_object().can_delete(self.request.user):
+                return super().get_delete_endpoint(**kwargs)
+        except (AssertionError, AttributeError, KeyError):
+            return None

wbcore/contrib/agenda/viewsets/menu/__init__.py

@@ -0,0 +1,2 @@
+from .calendar_items import CALENDAR_MENUITEM
+from .conference_room import BUILDING_MENUITEM, CONFERENCE_ROOM_MENUITEM

wbcore/contrib/agenda/viewsets/menu/calendar_items.py

@@ -0,0 +1,17 @@
+from django.utils.translation import gettext as _
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+
+def default_calendar_get_params(request) -> dict:
+    return {"entities": request.user.profile.id}
+
+
+CALENDAR_MENUITEM = MenuItem(
+    label=_("Calendar"),
+    endpoint="wbcore:agenda:calendaritem-list",
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user), permissions=["agenda.view_calendaritem"]
+    ),
+    endpoint_get_parameters=default_calendar_get_params,
+)

wbcore/contrib/agenda/viewsets/menu/conference_room.py

@@ -0,0 +1,37 @@
+from django.utils.translation import gettext as _
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+BUILDING_MENUITEM = MenuItem(
+    label=_("Buildings"),
+    endpoint="wbcore:agenda:building-list",
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user),
+        permissions=["agenda.view_building"],
+    ),
+    add=MenuItem(
+        label=_("Create Building"),
+        endpoint="wbcore:agenda:building-list",
+        permission=ItemPermission(
+            method=lambda request: is_internal_user(request.user),
+            permissions=["agenda.add_building"],
+        ),
+    ),
+)
+
+CONFERENCE_ROOM_MENUITEM = MenuItem(
+    label=_("Conference Rooms"),
+    endpoint="wbcore:agenda:conferenceroom-list",
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user),
+        permissions=["agenda.view_conferenceroom"],
+    ),
+    add=MenuItem(
+        label=_("Create Conference Room"),
+        endpoint="wbcore:agenda:conferenceroom-list",
+        permission=ItemPermission(
+            method=lambda request: is_internal_user(request.user),
+            permissions=["agenda.add_conferenceroom"],
+        ),
+    ),
+)

wbcore/contrib/agenda/viewsets/titles/__init__.py

@@ -0,0 +1,2 @@
+from .calendar_items import CalendarItemTitleConfig
+from .conference_room import BuildingTitleConfig, ConferenceRoomTitleConfig

wbcore/contrib/agenda/viewsets/titles/calendar_items.py

@@ -0,0 +1,7 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class CalendarItemTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("Calendar")