fixup! ✨(backend) add EmailTemplate model and API

Author: sdemagny

src/backend/core/admin.py

@@ -526,35 +526,35 @@ class DKIMKeyAdmin(admin.ModelAdmin):
     )
 
 
-class EmailTemplateMailDomainInline(admin.TabularInline):
-    """Inline class for the EmailTemplateMailDomain model"""
+class MessageTemplateMailDomainInline(admin.TabularInline):
+    """Inline class for the MessageTemplateMailDomain model"""
 
-    model = models.EmailTemplateMailDomain
+    model = models.MessageTemplateMailDomain
     extra = 1
 
 
-class EmailTemplateMailboxInline(admin.TabularInline):
-    """Inline class for the EmailTemplateMailbox model"""
+class MessageTemplateMailboxInline(admin.TabularInline):
+    """Inline class for the MessageTemplateMailbox model"""
 
-    model = models.EmailTemplateMailbox
+    model = models.MessageTemplateMailbox
     extra = 1
 
 
-@admin.register(models.EmailTemplate)
-class EmailTemplateAdmin(admin.ModelAdmin):
-    """Admin class for the EmailTemplate model"""
+@admin.register(models.MessageTemplate)
+class MessageTemplateAdmin(admin.ModelAdmin):
+    """Admin class for the MessageTemplate model"""
 
-    inlines = [EmailTemplateMailDomainInline, EmailTemplateMailboxInline]
+    inlines = [MessageTemplateMailDomainInline, MessageTemplateMailboxInline]
     list_display = (
         "id",
         "name",
-        "type",
+        "kind",
         "is_active",
         "preview_content",
         "created_at",
     )
     list_filter = (
-        "type",
+        "kind",
         "is_active",
         "created_at",
     )
@@ -574,7 +574,7 @@ class EmailTemplateAdmin(admin.ModelAdmin):
                     "id",
                     "name",
                     "description",
-                    "type",
+                    "kind",
                 )
             },
         ),
@@ -606,38 +606,38 @@ def get_queryset(self, request):
         if request.user.is_superuser:
             return qs
         # Filter by mailboxes the user has access to
-        accessible_mailboxes = models.Mailbox.objects.filter(accesses__user=request.user)
+        accessible_mailboxes = models.Mailbox.objects.filter(
+            accesses__user=request.user
+        )
         return qs.filter(mailboxes__in=accessible_mailboxes)
 
     def preview_content(self, obj):
         """Display a preview of the formatted content."""
-        if obj.is_signature():
-            formatted = obj.get_formatted_content()
-            return format_html(
-                '<div style="max-width: 400px; overflow: hidden; text-overflow: ellipsis;">{}</div>',
-                formatted[:100] + "..." if len(formatted) > 100 else formatted,
-            )
-        return "N/A (not a signature)"
+        formatted = obj.get_formatted_content()
+        return format_html(
+            '<div style="max-width: 400px; overflow: hidden; text-overflow: ellipsis;">{}</div>',
+            formatted[:100] + "..." if len(formatted) > 100 else formatted,
+        )
 
     preview_content.short_description = "Content Preview"
     preview_content.allow_tags = True
 
 
-@admin.register(models.EmailTemplateMailDomain)
-class EmailTemplateMailDomainAdmin(admin.ModelAdmin):
-    """Admin class for the EmailTemplateMailDomain model"""
+@admin.register(models.MessageTemplateMailDomain)
+class MessageTemplateMailDomainAdmin(admin.ModelAdmin):
+    """Admin class for the MessageTemplateMailDomain model"""
 
     list_display = ("id", "template", "maildomain", "is_default")
-    list_filter = ("is_default", "template__type", "maildomain")
+    list_filter = ("is_default", "template__kind", "maildomain")
     search_fields = ("template__name", "maildomain__name")
     ordering = ("template__name", "maildomain__name")
 
 
-@admin.register(models.EmailTemplateMailbox)
-class EmailTemplateMailboxAdmin(admin.ModelAdmin):
-    """Admin class for the EmailTemplateMailbox model"""
+@admin.register(models.MessageTemplateMailbox)
+class MessageTemplateMailboxAdmin(admin.ModelAdmin):
+    """Admin class for the MessageTemplateMailbox model"""
 
     list_display = ("id", "template", "mailbox", "is_default")
-    list_filter = ("is_default", "template__type", "mailbox__domain")
+    list_filter = ("is_default", "template__kind", "mailbox__domain")
     search_fields = ("template__name", "mailbox__local_part", "mailbox__domain__name")
     ordering = ("template__name", "mailbox__local_part")

src/backend/core/api/serializers.py

@@ -853,20 +853,20 @@ class ImportIMAPSerializer(ImportBaseSerializer):
     )
 
 
-class EmailTemplateSerializer(AbilitiesModelSerializer):
-    """Serialize email templates."""
+class MessageTemplateSerializer(AbilitiesModelSerializer):
+    """Serialize message templates."""
 
-    type = IntegerChoicesField(choices_class=models.TemplateTypeChoices)
+    kind = IntegerChoicesField(choices_class=models.MessageTemplateKindChoices)
 
     class Meta:
-        model = models.EmailTemplate
+        model = models.MessageTemplate
         fields = [
             "id",
             "name",
             "description",
             "html_body",
             "text_body",
-            "type",
+            "kind",
             "is_active",
             "created_at",
             "updated_at",
@@ -875,14 +875,22 @@ class Meta:
 
     def validate(self, attrs):
         """Validate template data."""
+        html_body = attrs.get("html_body", "")
+        text_body = attrs.get("text_body", "")
+
+        if not html_body and not text_body:
+            raise serializers.ValidationError(
+                "At least one of html_body or text_body must be provided."
+            )
+
         # Ensure only one default template per type per mailbox/maildomain
         if attrs.get("is_active"):
-            template_type = attrs.get("type")
+            template_kind = attrs.get("kind")
 
-            if template_type:
-                # Check if another default template exists for this type
-                existing_default = models.EmailTemplate.objects.filter(
-                    type=template_type,
+            if template_kind:
+                # Check if another default template exists for this kind
+                existing_default = models.MessageTemplate.objects.filter(
+                    kind=template_kind,
                     is_active=True,
                 )
 
@@ -892,20 +900,20 @@ def validate(self, attrs):
 
                 if existing_default.exists():
                     raise serializers.ValidationError(
-                        f"Another default {template_type} template already exists."
+                        f"Another default {template_kind} template already exists."
                     )
 
         return attrs
 
 
-class EmailTemplateMailDomainSerializer(serializers.ModelSerializer):
-    """Serialize EmailTemplate to MailDomain relationships."""
+class MessageTemplateMailDomainSerializer(serializers.ModelSerializer):
+    """Serialize MessageTemplate to MailDomain relationships."""
 
     template_name = serializers.CharField(source="template.name", read_only=True)
     maildomain_name = serializers.CharField(source="maildomain.name", read_only=True)
 
     class Meta:
-        model = models.EmailTemplateMailDomain
+        model = models.MessageTemplateMailDomain
         fields = [
             "id",
             "template",
@@ -919,14 +927,14 @@ class Meta:
         read_only_fields = ["id", "created_at", "updated_at"]
 
 
-class EmailTemplateMailboxSerializer(serializers.ModelSerializer):
-    """Serialize EmailTemplate to Mailbox relationships."""
+class MessageTemplateMailboxSerializer(serializers.ModelSerializer):
+    """Serialize MessageTemplate to Mailbox relationships."""
 
     template_name = serializers.CharField(source="template.name", read_only=True)
     mailbox_email = serializers.CharField(source="mailbox", read_only=True)
 
     class Meta:
-        model = models.EmailTemplateMailbox
+        model = models.MessageTemplateMailbox
         fields = [
             "id",
             "template",
@@ -940,12 +948,12 @@ class Meta:
         read_only_fields = ["id", "created_at", "updated_at"]
 
 
-class EmailTemplateLightSerializer(serializers.ModelSerializer):
-    """Light serializer for email templates in dropdowns and lists."""
+class MessageTemplateLightSerializer(serializers.ModelSerializer):
+    """Light serializer for message templates in dropdowns and lists."""
 
-    type = IntegerChoicesField(choices_class=models.TemplateTypeChoices)
+    kind = IntegerChoicesField(choices_class=models.MessageTemplateKindChoices)
 
     class Meta:
-        model = models.EmailTemplate
-        fields = ["id", "name", "type", "is_active"]
+        model = models.MessageTemplate
+        fields = ["id", "name", "kind", "is_active"]
         read_only_fields = fields

src/backend/core/api/viewsets/__init__.py

@@ -9,7 +9,6 @@
 import rest_framework as drf
 from rest_framework import viewsets
 
-
 logger = logging.getLogger(__name__)
 
 ITEM_FOLDER = "item"

src/backend/core/api/viewsets/email_template.py renamed to src/backend/core/api/viewsets/message_template.py

@@ -1,44 +1,43 @@
-"""API ViewSet for email templates."""
+"""API ViewSet for message templates."""
 
-from django.shortcuts import get_object_or_404
 
 from drf_spectacular.utils import OpenApiResponse, extend_schema
 from rest_framework import status, viewsets
 from rest_framework.decorators import action
 from rest_framework.response import Response
 
 from core.api import permissions
-from core.api.serializers import EmailTemplateSerializer
-from core.models import EmailTemplate, Mailbox, MailDomain, TemplateTypeChoices
+from core.api.serializers import MessageTemplateSerializer
+from core.models import Mailbox, MessageTemplate
 
 
-@extend_schema(tags=["email-templates"])
-class EmailTemplateViewSet(viewsets.ModelViewSet):  # pylint: disable=too-many-ancestors
+@extend_schema(tags=["message-templates"])
+class MessageTemplateViewSet(viewsets.ModelViewSet):  # pylint: disable=too-many-ancestors
     """
-    ViewSet for managing email templates and signatures.
+    ViewSet for managing message templates and signatures.
 
     This ViewSet provides endpoints for creating, reading, updating, and deleting
-    email templates and signatures. Templates can be used for replies, forwards,
+    message templates and signatures. Templates can be used for replies, forwards,
     new messages, auto-replies, and signatures.
 
     Filtering:
-    - type: Filter by template type (reply, forward, new_message, auto_reply, signature)
+    - kind: Filter by template kind (reply, forward, new_message, auto_reply, signature)
     - is_active: Filter by active status (true/false)
     - mailbox: Filter by mailbox UUID
     - maildomain: Filter by mail domain UUID
     - is_default: Filter by default status (true/false) - works with mailbox or maildomain
     """
 
     permission_classes = [permissions.IsAuthenticated]
-    serializer_class = EmailTemplateSerializer
+    serializer_class = MessageTemplateSerializer
     filterset_fields = [
-        "type",
+        "kind",
         "is_active",
     ]
 
     ordering_fields = [
         "name",
-        "type",
+        "kind",
         "created_at",
         "updated_at",
     ]
@@ -49,11 +48,13 @@ def get_queryset(self):
         user = self.request.user
 
         if user.is_superuser:
-            queryset = EmailTemplate.objects.all()
+            queryset = MessageTemplate.objects.all()
         else:
             # Filter by mailboxes the user has access to
             accessible_mailboxes = Mailbox.objects.filter(accesses__user=user)
-            queryset = EmailTemplate.objects.filter(mailboxes__in=accessible_mailboxes)
+            queryset = MessageTemplate.objects.filter(
+                mailboxes__in=accessible_mailboxes
+            )
 
         # Apply custom filters
         mailbox_id = self.request.query_params.get("mailbox")
@@ -64,19 +65,22 @@ def get_queryset(self):
             queryset = queryset.filter(template_mailboxes__mailbox_id=mailbox_id)
             if is_default is not None:
                 is_default_bool = is_default.lower() in ("true", "1", "yes")
-                queryset = queryset.filter(template_mailboxes__is_default=is_default_bool)
+                queryset = queryset.filter(
+                    template_mailboxes__is_default=is_default_bool
+                )
 
         if maildomain_id:
-            queryset = queryset.filter(template_maildomains__maildomain_id=maildomain_id)
+            queryset = queryset.filter(
+                template_maildomains__maildomain_id=maildomain_id
+            )
             if is_default is not None:
                 is_default_bool = is_default.lower() in ("true", "1", "yes")
-                queryset = queryset.filter(template_maildomains__is_default=is_default_bool)
+                queryset = queryset.filter(
+                    template_maildomains__is_default=is_default_bool
+                )
 
         return queryset.distinct()
 
-
-
-
     @extend_schema(
         responses={
             200: OpenApiResponse(
@@ -95,11 +99,15 @@ def get_queryset(self):
     )
     @action(detail=True, methods=["get"], url_path="render")
     def render_template(self, request, pk=None):  # pylint: disable=unused-argument
-        """Render a template with the provided context."""
+        """Render a template with the provided mailbox uuid."""
         template = self.get_object()
-        # context -> mailbox uuid (+ fullname of user identified)
-        context = request.query_params.get("context", {})
-        
+        mailbox_id = request.query_params.get("mailbox_id", None)
+        user = request.user
+        mailbox = Mailbox.objects.get(id=mailbox_id)
+        context = {
+            "mailbox": str(mailbox),
+            "fullname": user.get_full_name(),
+        }
         try:
             rendered = template.render_template(context)
             return Response(rendered)

src/backend/core/enums.py

@@ -79,8 +79,8 @@ class UserAbilityChoices(models.TextChoices):
     CAN_CREATE_MAILDOMAINS = "create_maildomains", "Can create maildomains"
 
 
-class TemplateTypeChoices(models.IntegerChoices):
-    """Defines the possible types of email templates."""
+class MessageTemplateKindChoices(models.IntegerChoices):
+    """Defines the possible kinds of message templates."""
 
     REPLY = 1, "reply"
     FORWARD = 2, "forward"