wbcore 2.2.1__py2.py3-none-any.whl

wbcore/configurations/configurations/authentication.py

@@ -0,0 +1,43 @@
+from datetime import timedelta
+
+from configurations import values
+
+
+class Authentication:
+    AUTHENTICATION_BACKENDS = (
+        "django.contrib.auth.backends.ModelBackend",  # this is default
+        "guardian.backends.ObjectPermissionBackend",
+    )
+
+    AUTH_PASSWORD_VALIDATORS = [
+        {"NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator"},
+        {"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator"},
+        {"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator"},
+        {"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator"},
+    ]
+
+    JWT_AUTH = {"JWT_AUTH_COOKIE": "JWT"}
+
+    @property
+    def SIMPLE_JWT(self):
+        return {
+            "ACCESS_TOKEN_LIFETIME": timedelta(
+                minutes=values.PositiveIntegerValue(5, environ_name="JWT_ACCESS_TOKEN_LIFETIME", environ_prefix=None)
+            ),
+            "REFRESH_TOKEN_LIFETIME": timedelta(
+                days=values.PositiveIntegerValue(1, environ_name="JWT_REFRESH_TOKEN_LIFETIME", environ_prefix=None)
+            ),
+            "ALGORITHM": "HS256",
+            "SIGNING_KEY": self.SECRET_KEY,
+            "ROTATE_REFRESH_TOKENS": False,
+            "BLACKLIST_AFTER_ROTATION": True,
+            "VERIFYING_KEY": None,
+            "AUTH_HEADER_TYPES": ("Bearer",),
+            "USER_ID_FIELD": "id",
+            "USER_ID_CLAIM": "user_id",
+            "AUTH_TOKEN_CLASSES": ("rest_framework_simplejwt.tokens.AccessToken",),
+            "TOKEN_TYPE_CLAIM": "token_type",
+            "SLIDING_TOKEN_REFRESH_EXP_CLAIM": "refresh_exp",
+            "SLIDING_TOKEN_LIFETIME": timedelta(minutes=5),
+            "SLIDING_TOKEN_REFRESH_LIFETIME": timedelta(days=1),
+        }

wbcore/configurations/configurations/base.py

@@ -0,0 +1,15 @@
+import os
+
+from configurations import values
+
+
+class Base:
+    DEBUG = values.BooleanValue(True, environ_prefix=None)
+    SECRET_KEY = values.Value("THIS-IS-NOT-A-SECRET-KEY", environ_prefix=None)
+    SITE_ID = values.IntegerValue(1, environ_prefix=None)
+
+    @property
+    def PROJECT_NAME(self):
+        if settings_module := os.environ.get("DJANGO_SETTINGS_MODULE", None):
+            return settings_module.split(".")[0]
+        return None

wbcore/configurations/configurations/cache.py

@@ -0,0 +1,20 @@
+from configurations import values
+
+
+class Cache:
+    CACHE_REDIS_URL = values.Value(None, environ_prefix=None)
+    CACHE_TIMEOUT = values.IntegerValue(
+        10 * 24 * 3600, environ_prefix=None
+    )  # The default (10 days) timeout in seconds
+
+    @property
+    def CACHES(self):
+        if self.CACHE_REDIS_URL:
+            return {
+                "default": {
+                    "BACKEND": "django.core.cache.backends.redis.RedisCache",
+                    "LOCATION": self.CACHE_REDIS_URL,
+                    "TIMEOUT": self.CACHE_TIMEOUT,
+                }
+            }
+        return {"default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache", "TIMEOUT": self.CACHE_TIMEOUT}}

wbcore/configurations/configurations/celery.py

@@ -0,0 +1,26 @@
+from configurations import values
+
+
+class CeleryTest:
+    CELERY_TASK_ALWAYS_EAGER = True
+
+
+class Celery:
+    CELERY_BROKER_TRANSPORT_OPTIONS = {
+        "max_retries": 3,
+        "interval_start": 0,
+        "interval_step": 0.2,
+        "interval_max": 0.5,
+    }
+    CELERY_BROKER_URL = values.Value("redis://localhost:6379", environ_name="REDIS_URL", environ_prefix=None)
+    CELERY_BROKER_CONNECTION_RETRY_ON_STARTUP = values.BooleanValue(True, environ_prefix=None)
+    CELERY_TASK_SERIALIZER = values.Value("pickle", environ_prefix=None)
+    CELERY_ACCEPT_CONTENT = values.ListValue(["json", "pickle"], environ_prefix=None)
+    CELERY_RESULT_SERIALIZER = values.Value("json", environ_prefix=None)
+    CELERY_BEAT_SCHEDULER = "django_celery_beat.schedulers:DatabaseScheduler"
+    CELERY_RESULT_BACKEND = values.Value("redis://localhost:6379", environ_name="REDIS_URL", environ_prefix=None)
+
+    if "rediss://" in CELERY_BROKER_URL:
+        CELERY_BROKER_USE_SSL = {"ssl_cert_reqs": "none"}
+    else:
+        CELERY_BROKER_USE_SSL = {}

wbcore/configurations/configurations/i18nl10n.py

@@ -0,0 +1,10 @@
+from configurations import values
+
+
+class I18NL10N:
+    TIME_ZONE = values.Value("Europe/Berlin", environ_prefix=None)
+    LANGUAGE_CODE = values.Value("en-us", environ_prefix=None)
+    USE_TZ = values.BooleanValue(True, environ_prefix=None)
+    USE_I18N = values.BooleanValue(
+        False, environ_prefix=None
+    )  # Setting to True lead to a big performance hit when resolver needs to translate url

wbcore/configurations/configurations/mail.py

@@ -0,0 +1,2 @@
+class ConsoleEmail:
+    EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

wbcore/configurations/configurations/maintenance.py

@@ -0,0 +1,53 @@
+from configurations import values
+from django.conf import settings
+
+
+class Maintenance:
+    MAINTENANCE_MODE_STR: str | None = values.Value("False", environ_prefix=None)
+
+    # We allow maintenance mode to be either True, False or None. In case of None, the specified Backend will take over.
+    def MAINTENANCE_MODE(self) -> bool | None:
+        if value := self.MAINTENANCE_MODE_STR:
+            normalized_value = value.strip().lower()
+            if normalized_value in values.BooleanValue.true_values:
+                return True
+            elif normalized_value in values.BooleanValue.false_values:
+                return False
+        return None
+
+    MAINTENANCE_MODE_STATE_BACKEND = values.Value(
+        "maintenance_mode.backends.StaticStorageBackend", environ_prefix=None
+    )
+    MAINTENANCE_MODE_STATE_BACKEND_FALLBACK_VALUE = False
+    MAINTENANCE_MODE_STATE_FILE_NAME = values.Value("maintenance_mode_state.txt", environ_prefix=None)
+
+    MAINTENANCE_MODE_IGNORE_ADMIN_SITE = values.BooleanValue(True, environ_prefix=None)
+    MAINTENANCE_MODE_IGNORE_ANONYMOUS_USER = False
+    MAINTENANCE_MODE_IGNORE_AUTHENTICATED_USER = False
+    MAINTENANCE_MODE_IGNORE_STAFF = values.BooleanValue(False, environ_prefix=None)
+    MAINTENANCE_MODE_IGNORE_SUPERUSER = values.BooleanValue(True, environ_prefix=None)
+    MAINTENANCE_MODE_IGNORE_IP_ADDRESSES = values.ListValue([], environ_prefix=None)
+
+    MAINTENANCE_MODE_GET_CONTEXT = None
+    MAINTENANCE_MODE_IGNORE_URLS = values.ListValue([], environ_prefix=None)
+
+    MAINTENANCE_MODE_LOGOUT_AUTHENTICATED_USER = False
+    MAINTENANCE_MODE_REDIRECT_URL = values.Value(None, environ_prefix=None)
+    MAINTENANCE_MODE_RESPONSE_TYPE = values.Value("html", environ_prefix=None)
+    MAINTENANCE_MODE_TEMPLATE = values.Value("errors/503.html", environ_prefix=None)
+
+    MAINTENANCE_MODE_STATUS_CODE = values.IntegerValue(503, environ_prefix=None)
+    MAINTENANCE_MODE_RETRY_AFTER = values.IntegerValue(3600, environ_prefix=None)  # 1 hour
+
+    MAINTENANCE_MODE_IGNORE_TESTS = False
+    MAINTENANCE_MODE_GET_CONTEXT = "wbcore.configurations.configurations.maintenance.get_context"
+
+    MAINTENANCE_MODE_HEADER = values.Value("We're doing some maintenance", environ_prefix=None)
+    MAINTENANCE_MODE_DESCRIPTION = values.Value(
+        "Our site is currently undergoing scheduled maintenance and upgrades, but will return shortly. Thank for your patience",
+        environ_prefix=None,
+    )
+
+
+def get_context(request=None):
+    return {"header": settings.MAINTENANCE_MODE_HEADER, "description": settings.MAINTENANCE_MODE_DESCRIPTION}

wbcore/configurations/configurations/media.py

@@ -0,0 +1,22 @@
+from configurations import values
+
+
+class Media:
+    MEDIA_URL = "/media/"
+
+
+class LocalMedia(Media):
+    @property
+    def MEDIA_ROOT(self):
+        return self.BASE_DIR.joinpath("mediafiles")
+
+
+class S3Media(Media):
+    AWS_ACCESS_KEY_ID = values.Value("minio_access_key", environ_prefix=None)
+    AWS_SECRET_ACCESS_KEY = values.Value("minio_secret_access_key", environ_prefix=None)
+
+    AWS_S3_REGION_NAME = values.Value("", environ_prefix=None)
+    AWS_S3_ENDPOINT_URL = values.Value("http://localhost:9000", environ_prefix=None)
+    AWS_S3_SIGNATURE_VERSION = values.Value("s3v4", environ_prefix=None)
+    AWS_DEFAULT_ACL = values.Value(None, environ_prefix=None)
+    AWS_S3_FILE_OVERWRITE = values.BooleanValue(False, environ_prefix=None)

wbcore/configurations/configurations/middleware.py

@@ -0,0 +1,27 @@
+class Middleware:
+    MIDDLEWARE = [
+        "django.middleware.security.SecurityMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "corsheaders.middleware.CorsMiddleware",
+        "django.middleware.common.CommonMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.middleware.clickjacking.XFrameOptionsMiddleware",
+        # "maintenance_mode.middleware.MaintenanceModeMiddleware", # we leave it commented for now to try out the performance gain to not evaluate maintenance mode on every request lifecycle
+    ]
+
+
+class DevMiddleware:
+    @property
+    def MIDDLEWARE(self):
+        middleware = []
+        middleware_list = Middleware.MIDDLEWARE.copy()
+        if self.DEBUG:
+            middleware.append("debug_toolbar.middleware.DebugToolbarMiddleware")
+        middleware_list.insert(
+            middleware_list.index("django.contrib.sessions.middleware.SessionMiddleware") + 1,
+            "django.middleware.locale.LocaleMiddleware",
+        )  # The django "LocaleMiddleware" needs to come after "SessionMiddleware" and before "CommonMiddleware".
+        middleware.extend(middleware_list)
+        return middleware

wbcore/configurations/configurations/network.py

@@ -0,0 +1,19 @@
+from configurations import values
+from corsheaders.defaults import default_headers
+
+
+class Network:
+    ALLOWED_HOSTS = values.ListValue(["*"], environ_prefix=None)
+    CORS_ALLOW_ALL_ORIGINS = values.BooleanValue(True, environ_prefix=None)
+    CORS_ALLOWED_ORIGINS = values.ListValue([], environ_prefix=None)
+    CORS_ALLOW_HEADERS = list(default_headers) + ["WB-DISPLAY-IDENTIFIER"]
+    DATA_UPLOAD_MAX_MEMORY_SIZE = values.IntegerValue(2621440, environ_prefix=None)
+    DATA_UPLOAD_MAX_NUMBER_FIELDS = values.IntegerValue(1000, environ_prefix=None)
+    DATA_UPLOAD_MAX_NUMBER_FILES = values.IntegerValue(100, environ_prefix=None)
+
+
+class SSLNetwork(Network):
+    SECURE_SSL_REDIRECT = True
+    SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
+    SESSION_COOKIE_SECURE = True
+    CSRF_COOKIE_SECURE = True

wbcore/configurations/configurations/rest_framework.py

@@ -0,0 +1,42 @@
+from configurations import values
+
+
+class Restframework:
+    REST_FRAMEWORK_ANON_THROTTLE_RATES = values.IntegerValue(60, environ_prefix=None)
+    REST_FRAMEWORK_THROTTLE_PERIOD = values.Value("hour", environ_prefix=None)
+    REST_FRAMEWORK_USER_THROTTLE_RATES = values.IntegerValue(5000, environ_prefix=None)
+
+    def REST_FRAMEWORK(self):
+        rest_framework = {
+            "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.LimitOffsetPagination",
+            "PAGE_SIZE": 25,
+            "DEFAULT_RENDERER_CLASSES": ("rest_framework.renderers.JSONRenderer",),
+            "DEFAULT_AUTHENTICATION_CLASSES": (
+                "rest_framework_simplejwt.authentication.JWTAuthentication",
+                "wbcore.contrib.authentication.authentication.TokenAuthentication",
+            ),
+            "DEFAULT_PERMISSION_CLASSES": (
+                "rest_framework.permissions.IsAuthenticated",
+                "wbcore.permissions.permissions.RestAPIModelPermissions",
+            ),
+            "DATETIME_FORMAT": "%Y-%m-%dT%H:%M:%S%z",
+            "DEFAULT_THROTTLE_CLASSES": [
+                "rest_framework.throttling.AnonRateThrottle",
+                "rest_framework.throttling.UserRateThrottle",
+            ],
+            "DEFAULT_THROTTLE_RATES": {
+                "anon": f"{self.REST_FRAMEWORK_ANON_THROTTLE_RATES}/{self.REST_FRAMEWORK_THROTTLE_PERIOD}",
+                "user": f"{self.REST_FRAMEWORK_USER_THROTTLE_RATES}/{self.REST_FRAMEWORK_THROTTLE_PERIOD}",
+            },
+        }
+        if self.DEBUG:
+            rest_framework["DEFAULT_AUTHENTICATION_CLASSES"] = (
+                "rest_framework_simplejwt.authentication.JWTAuthentication",
+                "wbcore.contrib.authentication.authentication.TokenAuthentication",
+                "rest_framework.authentication.SessionAuthentication",
+            )
+            rest_framework["DEFAULT_RENDERER_CLASSES"] = (
+                "rest_framework.renderers.JSONRenderer",
+                "wbcore.utils.renderers.BrowsableAPIRendererWithoutForms",
+            )
+        return rest_framework

wbcore/configurations/configurations/static.py

@@ -0,0 +1,28 @@
+class Staticfiles:
+    STATIC_URL = "static/"
+
+
+class LocalStaticfiles(Staticfiles):
+    STORAGES = {
+        "default": {
+            "BACKEND": "django.core.files.storage.FileSystemStorage",
+        },
+        "staticfiles": {
+            "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
+        }
+    }
+
+    @property
+    def STATIC_ROOT(self):
+        return self.BASE_DIR.joinpath("staticfiles")
+
+
+class S3Staticfiles(Staticfiles):
+    STORAGES = {
+        "default": {
+            "BACKEND": "storages.backends.s3boto3.S3Boto3Storage",
+        },
+        "staticfiles": {
+            "BACKEND": "storages.backends.s3boto3.S3Boto3Storage",
+        }
+    }

wbcore/configurations/configurations/templates.py

@@ -0,0 +1,17 @@
+class Templates:
+    TEMPLATES = [
+        {
+            "BACKEND": "django.template.backends.django.DjangoTemplates",
+            "NAME": "django",
+            "DIRS": [],
+            "APP_DIRS": True,
+            "OPTIONS": {
+                "context_processors": [
+                    "django.template.context_processors.debug",
+                    "django.template.context_processors.request",
+                    "django.contrib.auth.context_processors.auth",
+                    "django.contrib.messages.context_processors.messages",
+                ],
+            },
+        },
+    ]

wbcore/configurations/configurations/uvicorn.py

@@ -0,0 +1,9 @@
+from configurations import values
+
+
+class Uvicorn:
+    UVICORN_LOOP = values.Value("auto", environ_prefix=None)
+    # assert UVICORN_LOOP in ["auto", "uvloop", "asyncio"], "UVICORN_LOOP has an invalid setting"
+
+    UVICORN_WS = values.Value("auto", environ_prefix=None)
+    # assert UVICORN_WS in ["auto", "websockets", "wsproto"], "UVICORN_WS has an invalid setting"

wbcore/configurations/configurations/wbcore.py

@@ -0,0 +1,68 @@
+from configurations import values
+from django.utils.translation import gettext_lazy as _
+from markdown.extensions.tables import TableExtension
+from markdown_blockdiag.extension import BlockdiagExtension
+from wbcore.fsm.markdown_extensions import FSMExtension
+
+
+class WBCore:
+    CDN_BASE_ENDPOINT_URL = values.URLValue(
+        "https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/static", environ_prefix=None
+    )
+
+    FRONTEND_VERSION = values.Value("2.6.3", environ_prefix=None)
+    FRONTEND_TEMPLATE = "wbcore/frontend.html"
+    FRONTEND_MENU_CALENDAR = None
+
+    BASE_ENDPOINT_URL = values.Value("", environ_prefix=None)
+
+    BETA_BUTTON_VERSION = values.Value(None, environ_prefix=None)
+    BETA_BUTTON_URL = values.URLValue(None, environ_prefix=None)
+    BETA_BUTTON_TEXT = values.Value(_("Check out our upcoming beta version"), environ_prefix=None)
+
+    WBCORE_MARKDOWN_TEMPLATE_TAGS = []
+    WBCORE_MARKDOWN_EXTENSIONS = [
+        TableExtension(),
+        FSMExtension(),
+        BlockdiagExtension(format="svg"),
+    ]
+
+    WBCORE_NOTIFICATION_TEMPLATE = values.Value("notifications/email_template.html", environ_prefix=None)
+    WBCORE_NOTIFICATION_EMAIL_FROM = values.Value("no-reply@stainly-bench.com", environ_prefix=None)
+
+    WBCORE_PLOTLY_CDN_URL = values.Value("https://cdn.plot.ly/plotly-latest.min.js", environ_prefix=None)
+    WBCORE_TINYMCE_CDN_URL = values.Value(
+        "https://cdn.tiny.cloud/1/735nruhl1ud549mz9imjqabxpknlo6d9n308ev0iqs05gk03/tinymce/5/tinymce.min.js",
+        environ_prefix=None,
+    )
+    WBCORE_EXTRA_CDN_URLS = values.ListValue([], environ_prefix=None)
+    WBCORE_EXTRA_CSS_URLS = values.ListValue([], environ_prefix=None)
+    WBCORE_PROFILE = values.Value("wbcore.contrib.authentication.configuration.resolve_profile", environ_prefix=None)
+    WBCORE_DEFAULT_FRONTEND_USER_CONFIGURATION_ORDER = values.ListValue(["config__order"], environ_prefix=None)
+    WBCORE_DEFAULT_AUTH_CONFIG = values.Value("wbcore.auth.jwt_auth", environ_prefix=None)
+    WBCORE_DEFAULT_USER_NAME = values.Value("wbcore.auth.get_user_name", environ_prefix=None)
+    WBCORE_ADDITIONAL_DEFAULT_MODELVIEW_ATTRIBUTES = values.ListValue([], environ_prefix=None)
+    WBCORE_NEW_NOTIFICATION_SYSTEM = values.BooleanValue(False, environ_prefix=None)
+
+    DATA_UPLOAD_MAX_NUMBER_FIELDS = values.IntegerValue(2000, environ_prefix=None)
+    WBCORE_IDLE_TIME = values.IntegerValue(30 * 60, environ_prefix=None)  # value in seconds
+    WBCORE_IDLE_WARNING_TIME = values.IntegerValue(90, environ_prefix=None)  # value in seconds
+
+    MESSAGE_STORAGE = "wbcore.messages.InMemoryMessageStorage"
+
+    @property
+    def FRONTEND_CONTEXT(self):
+        base_url = f"{self.CDN_BASE_ENDPOINT_URL}/{self.FRONTEND_VERSION}/"
+        return {
+            "TITLE": "Workbench",
+            "FONT_URL": "https://fonts.googleapis.com/css?family=Roboto:400,400i,500,500i,700,900&display=swap",
+            "CDN_URLS": [self.WBCORE_PLOTLY_CDN_URL, self.WBCORE_TINYMCE_CDN_URL, *self.WBCORE_EXTRA_CDN_URLS],
+            "CSS_URLS": self.WBCORE_EXTRA_CSS_URLS,
+            "CONFIG_URL": "/wbcore/config/",
+            "FAVICON_URL": f"{self.CDN_BASE_ENDPOINT_URL}/favicon.ico",
+            "JS_URL": f"{base_url}main.js",
+            "CSS_URL": f"{base_url}main.css",
+            "JS_RUNTIME_URL": f"{base_url}runtime.js",
+            "IDLE_TIME": self.WBCORE_IDLE_TIME * 1000,  # convert it into milliseconds
+            "IDLE_WARNING_TIME": self.WBCORE_IDLE_WARNING_TIME * 1000,  # convert it into milliseconds
+        }

wbcore/content_type/admin.py

@@ -0,0 +1,8 @@
+from django.contrib import admin
+from django.contrib.contenttypes.models import ContentType
+
+
+@admin.register(ContentType)
+class ContentTypeModelAdmin(admin.ModelAdmin):
+    list_display = ["app_label", "model"]
+    search_fields = ["app_label", "model"]

wbcore/content_type/filters.py

@@ -0,0 +1,19 @@
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import FieldError
+from wbcore import filters as wb_filters
+
+
+class ContentTypeFilterSet(wb_filters.FilterSet):
+    related_name_isnull = wb_filters.CharFilter(method="filter_related_name_isnull")
+
+    def filter_related_name_isnull(self, queryset, label, value):
+        if value:
+            try:
+                return queryset.filter(**{f"{value}__isnull": False}).distinct()
+            except FieldError:
+                pass
+        return queryset
+
+    class Meta:
+        model = ContentType
+        fields = {"id": ["in", "exact"]}

wbcore/content_type/serializers.py

@@ -0,0 +1,89 @@
+import operator
+from functools import reduce
+
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.db.models import Q
+from wbcore import serializers
+
+
+class ContentTypeRepresentationSerializer(serializers.RepresentationSerializer):
+    endpoint = "wbcore:contenttyperepresentation-list"
+    value_key = "id"
+
+    model_title = serializers.SerializerMethodField()
+
+    def __init__(self, *args, model_callback_title=None, label_key="{{app_label}} | {{model}}", **kwargs):
+        self.allowed_types = kwargs.pop("allowed_types", ContentType.objects.none())
+
+        # for ease of use, we allow the allowed_type attribute to be set as a list of app_label and model (as tuple). In that case, we extract the valid content type queryset base on the join of conditions
+        if isinstance(self.allowed_types, list):
+            _conditions = [
+                (Q(app_label=allowed_type[0]) & Q(model__iexact=allowed_type[1]))
+                for allowed_type in self.allowed_types
+                if isinstance(allowed_type, tuple) and len(allowed_type) == 2
+            ]
+            if _conditions:
+                self.allowed_types = ContentType.objects.filter(reduce(operator.or_, _conditions))
+            else:
+                self.allowed_types = ContentType.objects.none()
+        self.model_callback_title = model_callback_title
+        super().__init__(*args, label_key=label_key, **kwargs)
+
+    def get_model_title(self, obj):
+        return obj.model.title()
+
+    def _get_filter_params(self, request):
+        filter_params = super()._get_filter_params(request)
+        if self.allowed_types.exists():
+            filter_params["id__in"] = ",".join(map(str, self.allowed_types.values_list("id", flat=True)))
+        return filter_params
+
+    class Meta:
+        model = ContentType
+        read_only_fields = (
+            "app_label",
+            "model",
+            "model_title",
+        )
+        fields = ("id", "app_label", "model", "model_title")
+
+
+class GenericModel(models.Model):
+    id = models.IntegerField(primary_key=True)
+    label = models.CharField(max_length=256)
+
+    class Meta:
+        managed = False
+
+
+class DynamicObjectIDRepresentationSerializer(serializers.RepresentationSerializer):
+    endpoint = "wbcore:dynamiccontenttyperepresentation-list"
+    value_key = "{{id}}"
+    label_key = "{{label}}"
+
+    label = serializers.CharField(read_only=True)
+    id = serializers.CharField(read_only=True)
+
+    def __init__(self, *args, content_type_field_name: str = "content_type", **kwargs):
+        self.content_type_field_name = content_type_field_name
+        super().__init__(*args, **kwargs)
+
+    def to_representation(self, value):
+        representation = super().to_representation(value)
+        representation["id"] = getattr(value, "pk", value)
+        try:
+            if content_type := getattr(self.parent.instance, self.content_type_field_name, None):
+                obj = content_type.get_object_for_this_type(id=value)
+                representation["label"] = str(obj)
+        except Exception:
+            representation["label"] = str(representation["id"])
+        return representation
+
+    class Meta:
+        model = GenericModel
+        read_only_fields = (
+            "id",
+            "label",
+        )
+        fields = ("id", "label")

wbcore/content_type/utils.py

@@ -0,0 +1,30 @@
+from django.contrib.contenttypes.models import ContentType
+
+
+def get_ancestors_content_type(content_type):
+    """
+    Utility function to gather the ascendant models content types
+    Returns a generator
+    class A:
+        ...
+
+    Class B(A):
+        ...
+
+    get_ascendant_content_types(ContentType.objects.get_for_model(B)) = [
+        ContentType.objects.get_for_model(A),
+        ContentType.objects.get_for_model(B)
+    ]
+    """
+    for _class in content_type.model_class().__mro__:
+        try:
+            ancestor_content_type = ContentType.objects.get_for_model(_class)
+            if ancestor_content_type.model_class():
+                yield ancestor_content_type
+        except Exception:
+            pass
+
+
+def get_view_content_type_id(view):
+    model = view.get_queryset().model
+    return ContentType.objects.get_for_model(model).id

wbcore/content_type/viewsets.py

@@ -0,0 +1,80 @@
+import re
+from contextlib import suppress
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import FieldDoesNotExist, FieldError
+from django.db.models import CharField, Value
+from django.db.models.functions import Concat
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from wbcore import viewsets
+
+from .filters import ContentTypeFilterSet
+from .serializers import (
+    ContentTypeRepresentationSerializer,
+    DynamicObjectIDRepresentationSerializer,
+    GenericModel,
+)
+
+
+class ContentTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    filterset_class = ContentTypeFilterSet
+    queryset = ContentType.objects.all()
+    serializer_class = ContentTypeRepresentationSerializer
+    search_fields = ["app_label", "model"]
+
+
+class DynamicObjectIDRepresentationViewSet(viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbcore:object_id"
+    queryset = GenericModel.objects.none()
+    search_fields = ["label"]
+
+    @cached_property
+    def model(self):
+        content_type = get_object_or_404(ContentType, pk=self.kwargs.get("pk", self.request.GET.get("content_type")))
+        return content_type.model_class()
+
+    @cached_property
+    def label_keys(self) -> list[str]:
+        label_keys = ["computed_str"]
+        if (r := getattr(self.model, "get_representation_label_key", None)) and callable(r):
+            label_keys = re.findall(r"\{\{(.*?)\}\}", r())
+        validated_keys = []
+        for key in label_keys:
+            with suppress(FieldDoesNotExist):
+                if self.model._meta.get_field(key):
+                    validated_keys.append(key)
+        return validated_keys
+
+    def get_serializer_class(self):
+        class ComputedStrSerializer(DynamicObjectIDRepresentationSerializer):
+            class Meta:
+                fields = ("id", "label", *self.label_keys)
+                model = self.model
+
+        return ComputedStrSerializer
+
+    def filter_queryset(self, queryset):
+        """
+        We allow basic filtering on the model fields
+        """
+        filter_params = dict(self.request.GET.dict())  # convert immutable QueryDict into a mutable dict
+        filter_params.pop("content_type", None)
+        for key, value in filter_params.items():
+            with suppress(FieldError, ValueError):
+                queryset = queryset.filter(**{key: value})
+        return super().filter_queryset(queryset)
+
+    def get_queryset(self):
+        try:
+            if not self.label_keys:
+                raise FieldError()
+            concat_fields = []
+            for field in self.label_keys:
+                concat_fields.append(field)
+                concat_fields.append(Value(" "))
+            return self.model.objects.annotate(
+                label=Concat(*concat_fields, output_field=CharField()),
+            )
+        except FieldError:
+            return self.model.objects.none()

wbcore/contrib/agenda/admin/__init__.py

@@ -0,0 +1,2 @@
+from .calendar_item import CalendarItemModelAdmin
+from .conference_room import BuildingModelAdmin, ConferenceRoomModelAdmin