wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/documents/viewsets/display/shareable_links.py

@@ -0,0 +1,66 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+
+from wbcore.contrib.color.enums import WBColor
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class ShareableLinkModelDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="valid_until", label=_("Valid Until")),
+                dp.Field(key="one_time_link", label=_("One Time Link")),
+                dp.Field(key="link", label=_("Link")),
+            ],
+            legends=[
+                dp.Legend(
+                    key="valid",
+                    items=[
+                        dp.LegendItem(
+                            icon=WBColor.GREEN_LIGHT.value,
+                            label=_("Valid"),
+                            value=True,
+                        ),
+                    ],
+                )
+            ],
+            formatting=[
+                dp.Formatting(
+                    column="valid",
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREEN_LIGHT.value},
+                            condition=("==", True),
+                        ),
+                    ],
+                ),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["link", "link"], ["valid_until", "one_time_link"], [repeat_field(2, "hits_section")]],
+            [create_simple_section("hits_section", _("Hits"), [["hits"]], "hits", collapsed=False)],
+        )
+
+
+class ShareableLinkAccessModelDisplay(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="accessed", label=_("Date")),
+                dp.Field(key="metadata_repr", label=_("Meta Data")),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["accessed", "metadata"]])

wbcore/contrib/documents/viewsets/document_model_relationships.py

@@ -0,0 +1,25 @@
+from wbcore import viewsets
+from wbcore.contrib.documents.models import DocumentModelRelationship
+from wbcore.contrib.documents.serializers import (
+    DocumentModelRelationshipModelSerializer,
+)
+from wbcore.contrib.documents.viewsets.display import (
+    DocumentModelRelationshipViewConfig,
+)
+from wbcore.contrib.documents.viewsets.endpoints.documents_model_relationships import (
+    DocumentModelRelationshipEndpointConfig,
+)
+
+
+class DocumentModelRelationshipModelViewSet(viewsets.ModelViewSet):
+    queryset = DocumentModelRelationship.objects.all()
+    serializer_class = DocumentModelRelationshipModelSerializer
+    display_config_class = DocumentModelRelationshipViewConfig
+    endpoint_config_class = DocumentModelRelationshipEndpointConfig
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        if document_id := self.kwargs.get("document_id", None):
+            queryset = queryset.filter(document_id=document_id)
+
+        return queryset

wbcore/contrib/documents/viewsets/document_types.py

@@ -0,0 +1,38 @@
+from django.db.models import Count
+
+from wbcore import viewsets
+from wbcore.contrib.documents.filters import DocumentTypeFilter
+from wbcore.contrib.documents.models import DocumentType
+from wbcore.contrib.documents.serializers import (
+    DocumentTypeModelSerializer,
+    DocumentTypeRepresentationSerializer,
+)
+from wbcore.contrib.documents.viewsets.buttons import DocumentTypeButtonConfig
+from wbcore.contrib.documents.viewsets.display import DocumentTypeModelDisplay
+from wbcore.contrib.documents.viewsets.titles import DocumentTypeModelTitleConfig
+
+
+class DocumentTypeModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/document_types.md"
+    search_fields = ("name",)
+    ordering = ["name"]
+    ordering_fields = (
+        "name",
+        "parent",
+    )
+    filterset_class = DocumentTypeFilter
+    queryset = DocumentType.objects.all()
+    serializer_class = DocumentTypeModelSerializer
+    title_config_class = DocumentTypeModelTitleConfig
+
+    button_config_class = DocumentTypeButtonConfig
+    display_config_class = DocumentTypeModelDisplay
+
+    def get_queryset(self):
+        return super().get_queryset().annotate(document_count=Count("documents"))
+
+
+class DocumentTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = DocumentType.objects.all()
+    serializer_class = DocumentTypeRepresentationSerializer
+    search_fields = ("name",)

wbcore/contrib/documents/viewsets/documents.py

@@ -0,0 +1,108 @@
+from contextlib import suppress
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
+from django.http.response import HttpResponse, HttpResponseRedirect
+from django.shortcuts import get_object_or_404
+from django.utils.translation import gettext as _
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from wbcore import viewsets
+from wbcore.content_type.utils import get_ancestors_content_type
+from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
+from wbcore.contrib.documents.filters import DocumentFilter
+from wbcore.contrib.documents.models import Document, DocumentModelRelationship
+from wbcore.contrib.documents.serializers import (
+    DocumentModelSerializer,
+    DocumentRepresentationSerializer,
+    ReadOnlyDocumentModelSerializer,
+)
+from wbcore.contrib.documents.viewsets.buttons import DocumentButtonConfig
+from wbcore.contrib.documents.viewsets.display import DocumentModelDisplay
+from wbcore.contrib.documents.viewsets.endpoints import DocumentEndpointConfig
+from wbcore.contrib.documents.viewsets.previews import DocumentPreviewConfig
+from wbcore.contrib.documents.viewsets.titles import DocumentModelTitleConfig
+from wbcore.contrib.guardian.viewsets.mixins import GuardianFilterMixin
+
+
+class DocumentModelViewSet(GuardianFilterMixin, viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/documents.md"
+    search_fields = ("name",)
+    ordering = ["-updated", "name"]
+    ordering_fields = ("name", "document_type", "updated")
+    filterset_class = DocumentFilter
+    preview_config_class = DocumentPreviewConfig
+    queryset = Document.objects.all()
+    serializer_class = DocumentModelSerializer
+    title_config_class = DocumentModelTitleConfig
+    endpoint_config_class = DocumentEndpointConfig
+    button_config_class = DocumentButtonConfig
+    display_config_class = DocumentModelDisplay
+
+    def get_queryset(self):
+        if (content_type_id := self.kwargs.get("content_type")) and (object_id := self.kwargs.get("content_id")):
+            content_types = list(get_ancestors_content_type(ContentType.objects.get_for_id(content_type_id)))
+            return (
+                super()
+                .get_queryset()
+                .filter(
+                    relationships__content_type__in=content_types,
+                    relationships__object_id=object_id,
+                )
+            )
+        return super().get_queryset()
+
+    def create(self, request, *args, **kwargs):
+        response = super().create(request, *args, **kwargs)
+
+        if (content_type_id := self.kwargs.get("content_type")) and (object_id := self.kwargs.get("content_id")):
+            DocumentModelRelationship.objects.create(
+                document_id=response.data["instance"]["id"],
+                content_type_id=content_type_id,
+                object_id=object_id,
+            )
+
+        return response
+
+    def get_serializer_class(self):
+        if "pk" in self.kwargs:
+            if (document := self.get_object()) and document.system_created:
+                return ReadOnlyDocumentModelSerializer
+        return super().get_serializer_class()
+
+    @action(detail=True, methods=["PATCH"])
+    def sendmail(self, request, pk=None):
+        document = get_object_or_404(Document, id=pk)
+        if to_email := request.POST.get("to_email", None):
+            document.send_email(to_email)
+            return Response(
+                {"__notification": {"title": _("Document is going to be sent with email")}},
+                status=status.HTTP_200_OK,
+            )
+        return Response(status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=False, methods=["GET"], authentication_classes=[JWTCookieAuthentication])
+    def urlredirect(self, request, pk=None):
+        """
+        List Action to redirect the document url when a unique relationship is found for the given content type pair values and optional query parameters
+        """
+        filter_kwargs = {"system_created": request.GET.get("system_created", "true") == "true"}
+        if "system_key" in request.GET:
+            filter_kwargs["system_key"] = request.GET["system_key"]
+
+        with suppress(Document.DoesNotExist, ObjectDoesNotExist, ContentType.DoesNotExist):
+            content_type = ContentType.objects.get_for_id(self.request.GET.get("content_type"))
+            obj = content_type.get_object_for_this_type(id=self.request.GET.get("object_id"))
+            document = Document.get_for_object(obj).get(**filter_kwargs)
+            if self.request.user.has_perm(Document.view_perm_str, document):
+                return HttpResponseRedirect(document.file.url)
+        return HttpResponse("Document could not be found", status=status.HTTP_404_NOT_FOUND)
+
+
+class DocumentRepresentationViewSet(GuardianFilterMixin, viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbcore:documents:documentrepresentation"
+    serializer_class = DocumentRepresentationSerializer
+    queryset = Document.objects.all()
+    search_fields = ("name",)

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

@@ -0,0 +1,5 @@
+from .documents import DocumentEndpointConfig
+from .shareable_links import (
+    ShareableLinkAccessEndpointConfig,
+    ShareableLinkEndpointConfig,
+)

wbcore/contrib/documents/viewsets/endpoints/documents.py

@@ -0,0 +1,20 @@
+from rest_framework.reverse import reverse
+
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class DocumentEndpointConfig(EndpointViewConfig):
+    def get_create_endpoint(self, **kwargs):
+        if "content_type" in self.view.kwargs and "content_id" in self.view.kwargs:
+            return reverse(
+                "wbcore:documents:document_content_object",
+                args=[self.view.kwargs["content_type"], self.view.kwargs["content_id"]],
+                request=self.request,
+            )
+        return super().get_create_endpoint(**kwargs)
+
+    def get_delete_endpoint(self, **kwargs):
+        if "pk" in self.view.kwargs:
+            if self.view.get_object().system_created:
+                return None
+        return super().get_delete_endpoint(**kwargs)

wbcore/contrib/documents/viewsets/endpoints/documents_model_relationships.py

@@ -0,0 +1,14 @@
+from rest_framework.reverse import reverse
+
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class DocumentModelRelationshipEndpointConfig(EndpointViewConfig):
+    def get_create_endpoint(self, **kwargs):
+        if document_id := self.view.kwargs.get("document_id", None):
+            return reverse(
+                "wbcore:documents:document-documentmodelrelationship-list",
+                args=[document_id],
+                request=self.request,
+            )
+        return super().get_create_endpoint(**kwargs)

wbcore/contrib/documents/viewsets/endpoints/shareable_links.py

@@ -0,0 +1,27 @@
+from rest_framework.reverse import reverse
+
+from wbcore.contrib.documents.models import ShareableLinkAccess
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class ShareableLinkEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        base_url = "wbcore:documents:link-list"
+
+        if doc_id := self.request.GET.get("document", None):
+            return f"{reverse(base_url, request=self.request)}?document={doc_id}"
+
+        return reverse(base_url, request=self.request)
+
+    def get_delete_endpoint(self, **kwargs):
+        try:
+            if ShareableLinkAccess.objects.filter(shareable_link=self.view.get_object()).exists():
+                return None
+        except AssertionError:
+            pass
+        return self.get_endpoint()
+
+
+class ShareableLinkAccessEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None

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

@@ -0,0 +1 @@
+from .documents import DMS_MENUITEM, DOCUMENT_TYPE_MENUITEM

wbcore/contrib/documents/viewsets/menu/documents.py

@@ -0,0 +1,25 @@
+from django.utils.translation import gettext as _
+
+from wbcore.menus import ItemPermission, MenuItem
+
+DMS_MENUITEM = MenuItem(
+    label=_("Documents"),
+    endpoint="wbcore:documents:document-list",
+    permission=ItemPermission(permissions=["documents.view_document"]),
+    add=MenuItem(
+        label=_("Create New Document"),
+        endpoint="wbcore:documents:document-list",
+        permission=ItemPermission(permissions=["documents.add_document"]),
+    ),
+)
+
+DOCUMENT_TYPE_MENUITEM = MenuItem(
+    label=_("Document Types"),
+    endpoint="wbcore:documents:documenttype-list",
+    permission=ItemPermission(permissions=["documents.view_documenttype"]),
+    add=MenuItem(
+        label=_("Create New Document Type"),
+        endpoint="wbcore:documents:documenttype-list",
+        permission=ItemPermission(permissions=["documents.add_documenttype"]),
+    ),
+)

wbcore/contrib/documents/viewsets/previews/__init__.py

@@ -0,0 +1 @@
+from .documents import DocumentPreviewConfig

wbcore/contrib/documents/viewsets/previews/documents.py

@@ -0,0 +1,10 @@
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.preview import PreviewViewConfig
+
+
+class DocumentPreviewConfig(PreviewViewConfig):
+    def get_display(self) -> Display:
+        return create_simple_display([["name", "document_type", "description"]])

wbcore/contrib/documents/viewsets/shareable_links.py

@@ -0,0 +1,110 @@
+import json
+from datetime import datetime
+from uuid import UUID
+
+from django.db.models import Q
+from django.http.request import HttpRequest
+from django.http.response import FileResponse, HttpResponse
+from django.shortcuts import get_object_or_404
+from django.views.generic import View
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from wbcore import viewsets
+from wbcore.contrib.documents.filters import (
+    ShareableLinkAccessFilter,
+    ShareableLinkFilter,
+)
+from wbcore.contrib.documents.models import ShareableLink, ShareableLinkAccess
+from wbcore.contrib.documents.serializers import (
+    ShareableLinkAccessModelSerializer,
+    ShareableLinkAccessRepresentationSerializer,
+    ShareableLinkModelSerializer,
+    ShareableLinkRepresentationSerializer,
+)
+from wbcore.contrib.documents.viewsets.buttons import ShareableLinkModelButtonConfig
+from wbcore.contrib.documents.viewsets.display import (
+    ShareableLinkAccessModelDisplay,
+    ShareableLinkModelDisplay,
+)
+from wbcore.contrib.documents.viewsets.endpoints import (
+    ShareableLinkAccessEndpointConfig,
+    ShareableLinkEndpointConfig,
+)
+from wbcore.contrib.documents.viewsets.titles import ShareableLinkModelTitleConfig
+
+
+class DownloadShareableLinkView(View):
+    def get(self, request: HttpRequest, uuid: UUID) -> HttpResponse:
+        link = get_object_or_404(ShareableLink, uuid=uuid)
+        if link.is_valid() and link.document.file.name:
+            json_meta = json.loads(json.dumps(request.META, default=str))
+            link.access(metadata=json_meta)
+            if (content_type := link.document.content_type) and (filename := link.document.filename):
+                with link.document.file.open("r") as f:
+                    return FileResponse(f, as_attachment=True, filename=filename, content_type=content_type)
+        return HttpResponse("Link invalid", status=status.HTTP_204_NO_CONTENT)
+
+
+class ShareableLinkModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/shareablelink.md"
+    search_fields = ("uuid",)
+    ordering = ["valid_until"]
+    ordering_fields = (
+        "valid_until",
+        "one_time_link",
+    )
+    queryset = ShareableLink.objects.all()
+    serializer_class = ShareableLinkModelSerializer
+    title_config_class = ShareableLinkModelTitleConfig
+    filterset_class = ShareableLinkFilter
+    endpoint_config_class = ShareableLinkEndpointConfig
+    button_config_class = ShareableLinkModelButtonConfig
+    display_config_class = ShareableLinkModelDisplay
+
+    @action(detail=True, methods=["PATCH"])
+    def invalidate(self, request, pk=None):
+        shareable_link = ShareableLink.objects.get(pk=pk)
+        if shareable_link.manual_invalid:
+            return Response({}, status=status.HTTP_400_BAD_REQUEST)
+        shareable_link.manual_invalid = True
+        shareable_link.save()
+        return Response({}, status=status.HTTP_200_OK)
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                valid=Q(manual_invalid=False) & (Q(valid_until__isnull=True) | Q(valid_until__gte=datetime.now()))
+            )
+        )
+
+
+class ShareableLinkRepresentationViewSet(viewsets.RepresentationViewSet):
+    serializer_class = ShareableLinkRepresentationSerializer
+    queryset = ShareableLink.objects.all()
+    search_fields = ("document",)
+
+
+class ShareableLinkAccessModelViewSet(viewsets.ModelViewSet):
+    LIST_DOCUMENTATION = "documents/markdown/documentation/shareablelinkaccess.md"
+    ordering = ["accessed"]
+    ordering_fields = (
+        "ipaddress",
+        "metadata",
+        "accessed",
+    )
+    queryset = ShareableLinkAccess.objects.all()
+    serializer_class = ShareableLinkAccessModelSerializer
+    endpoint_config_class = ShareableLinkAccessEndpointConfig
+    filterset_class = ShareableLinkAccessFilter
+
+    display_config_class = ShareableLinkAccessModelDisplay
+
+
+class ShareableLinkAccessRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = ShareableLinkAccess.objects.all()
+    serializer_class = ShareableLinkAccessRepresentationSerializer
+    search_fields = ("ipaddress",)

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

@@ -0,0 +1,3 @@
+from .document_types import DocumentTypeModelTitleConfig
+from .documents import DocumentModelTitleConfig
+from .shareable_links import ShareableLinkModelTitleConfig

wbcore/contrib/documents/viewsets/titles/document_types.py

@@ -0,0 +1,14 @@
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class DocumentTypeModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("Document Types")
+
+    def get_instance_title(self):
+        return _("Document Type: {{name}}")
+
+    def get_create_title(self):
+        return _("New Document Type")

wbcore/contrib/documents/viewsets/titles/documents.py

@@ -0,0 +1,27 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+def get_object_by_content(content_type, content_id):
+    return str(ContentType.objects.get_for_id(content_type).model_class().objects.get(id=content_id))
+
+
+class DocumentModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        if (content_id := self.view.kwargs.get("content_id", None)) and (
+            content_type := self.view.kwargs.get("content_type", None)
+        ):
+            return _("Documents for {object}").format(object=get_object_by_content(content_type, content_id))
+        return _("Documents")
+
+    def get_instance_title(self):
+        return _("Document: {{name}}")
+
+    def get_create_title(self):
+        if (content_id := self.view.kwargs.get("content_id", None)) and (
+            content_type := self.view.kwargs.get("content_type", None)
+        ):
+            return _("New Document for {object}").format(object=get_object_by_content(content_type, content_id))
+        return _("New Document")

wbcore/contrib/documents/viewsets/titles/shareable_links.py

@@ -0,0 +1,14 @@
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class ShareableLinkModelTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        return _("Shareable Links")
+
+    def get_instance_title(self):
+        return _("Shareable Link")
+
+    def get_create_title(self):
+        return _("New Shareable Link")

wbcore/contrib/dynamic_preferences/types.py

@@ -0,0 +1,127 @@
+from django.forms import fields as form_fields
+from dynamic_preferences.types import BooleanPreference as BaseBooleanPreference
+from dynamic_preferences.types import ChoicePreference as BaseChoicePreference
+from dynamic_preferences.types import DatePreference as BaseDatePreference
+from dynamic_preferences.types import DateTimePreference as BaseDateTimePreference
+from dynamic_preferences.types import DecimalPreference as BaseDecimalPreference
+from dynamic_preferences.types import DurationPreference as BaseDurationPreference
+from dynamic_preferences.types import FilePreference as BaseFilePreference
+from dynamic_preferences.types import FloatPreference as BaseFloatPreference
+from dynamic_preferences.types import IntegerPreference as BaseIntegerPreference
+from dynamic_preferences.types import LongStringPreference as BaseLongStringPreference
+from dynamic_preferences.types import ModelChoicePreference
+from dynamic_preferences.types import MultipleChoicePreference as BaseMultipleChoicePreference
+from dynamic_preferences.types import StringPreference as BaseStringPreference
+from dynamic_preferences.types import TimePreference as BaseTimePreference
+
+from wbcore.serializers import fields
+from wbcore.serializers.fields import LanguageChoiceField
+
+FIELD_MAPPING = {
+    form_fields.BooleanField: fields.BooleanField,
+    form_fields.IntegerField: fields.IntegerField,
+    form_fields.FloatField: fields.FloatField,
+    form_fields.DecimalField: fields.DecimalField,
+    form_fields.CharField: fields.CharField,
+    form_fields.ChoiceField: fields.ChoiceField,
+    form_fields.FileField: fields.FileField,
+    form_fields.DurationField: fields.DurationField,
+    form_fields.DateField: fields.DateField,
+    form_fields.DateTimeField: fields.DateTimeField,
+    form_fields.TimeField: fields.TimeField,
+    form_fields.MultipleChoiceField: fields.MultipleChoiceField,
+}
+
+
+class PreferenceMixin:
+    weight: int = 0
+
+    def get_api_additional_data(self):
+        return {}
+
+    def get_api_field_data(self):
+        field_class = FIELD_MAPPING[self.field_class]
+        kwargs = self.get_field_kwargs()
+        del kwargs["widget"]
+        rep = field_class(**kwargs, default=kwargs.get("initial")).get_representation(None, self.name)[1]
+        rep["required"] = True
+        return rep
+
+
+class BooleanPreference(PreferenceMixin, BaseBooleanPreference):
+    pass
+
+
+class IntegerPreference(PreferenceMixin, BaseIntegerPreference):
+    pass
+
+
+class DecimalPreference(PreferenceMixin, BaseDecimalPreference):
+    pass
+
+
+class FloatPreference(PreferenceMixin, BaseFloatPreference):
+    pass
+
+
+class StringPreference(PreferenceMixin, BaseStringPreference):
+    pass
+
+
+class LongStringPreference(PreferenceMixin, BaseLongStringPreference):
+    pass
+
+
+class ChoicePreference(PreferenceMixin, BaseChoicePreference):
+    pass
+
+
+class FilePreference(PreferenceMixin, BaseFilePreference):
+    pass
+
+
+class DurationPreference(PreferenceMixin, BaseDurationPreference):
+    pass
+
+
+class DatePreference(PreferenceMixin, BaseDatePreference):
+    pass
+
+
+class DateTimePreference(PreferenceMixin, BaseDateTimePreference):
+    pass
+
+
+class TimePreference(PreferenceMixin, BaseTimePreference):
+    pass
+
+
+class MultipleChoicePreference(PreferenceMixin, BaseMultipleChoicePreference):
+    pass
+
+
+class LanguageChoicePreference(PreferenceMixin, BaseChoicePreference):
+    def get_api_field_data(self):
+        kwargs = self.get_field_kwargs()
+        del kwargs["widget"]
+        rep = LanguageChoiceField(**kwargs, default=kwargs.get("initial")).get_representation(None, self.name)[1]
+        rep["required"] = True
+        return rep
+
+
+class CallableDefaultModelChoicePreference(ModelChoicePreference):
+    """
+    Propose a ModelChoicePreference class where default is allowed to be a callable property. This avoids unnecessary db calls at start
+
+    This type expects a mandatory model attribute and a section of type dynamic_preferences.Section.
+    """
+
+    def __init__(self, registry=None):
+        self.registry = registry
+        self.queryset = self.model.objects.all()
+        self.serializer = self.serializer_class(self.model)
+        self._setup_signals()
+
+    @property
+    def default(self):
+        raise NotImplementedError("Default property needs to be defined for this preference type")