🔥(backend) remove all code related to template

The template feature is removed.
Migration created to drop related tables.
Files modified:
- viewsets
- serializers
- models
- admin
- factories
- urls
- tests
- demo data

src/backend/core/api/permissions.py

@@ -98,10 +98,10 @@ class CanCreateInvitationPermission(permissions.BasePermission):
 
 
 class ResourceWithAccessPermission(permissions.BasePermission):
-    """A permission class for templates and invitations."""
+    """A permission class for invitations."""
 
     def has_permission(self, request, view):
-        """check create permission for templates."""
+        """check create permission."""
         return request.user.is_authenticated or view.action != "create"
 
     def has_object_permission(self, request, view, obj):

src/backend/core/api/serializers.py

@@ -59,30 +59,6 @@ class UserLightSerializer(UserSerializer):
         read_only_fields = ["full_name", "short_name"]
 
 
-class TemplateAccessSerializer(serializers.ModelSerializer):
-    """Serialize template accesses."""
-
-    abilities = serializers.SerializerMethodField(read_only=True)
-
-    class Meta:
-        model = models.TemplateAccess
-        resource_field_name = "template"
-        fields = ["id", "user", "team", "role", "abilities"]
-        read_only_fields = ["id", "abilities"]
-
-    def get_abilities(self, instance) -> dict:
-        """Return abilities of the logged-in user on the instance."""
-        request = self.context.get("request")
-        if request:
-            return instance.get_abilities(request.user)
-        return {}
-
-    def update(self, instance, validated_data):
-        """Make "user" field is readonly but only on update."""
-        validated_data.pop("user", None)
-        return super().update(instance, validated_data)
-
-
 class ListDocumentSerializer(serializers.ModelSerializer):
     """Serialize documents with limited fields for display in lists."""
 
@@ -660,52 +636,6 @@ class FileUploadSerializer(serializers.Serializer):
         return attrs
 
 
-class TemplateSerializer(serializers.ModelSerializer):
-    """Serialize templates."""
-
-    abilities = serializers.SerializerMethodField(read_only=True)
-    accesses = TemplateAccessSerializer(many=True, read_only=True)
-
-    class Meta:
-        model = models.Template
-        fields = [
-            "id",
-            "title",
-            "accesses",
-            "abilities",
-            "css",
-            "code",
-            "is_public",
-        ]
-        read_only_fields = ["id", "accesses", "abilities"]
-
-    def get_abilities(self, document) -> dict:
-        """Return abilities of the logged-in user on the instance."""
-        request = self.context.get("request")
-        if request:
-            return document.get_abilities(request.user)
-        return {}
-
-
-# pylint: disable=abstract-method
-class DocumentGenerationSerializer(serializers.Serializer):
-    """Serializer to receive a request to generate a document on a template."""
-
-    body = serializers.CharField(label=_("Body"))
-    body_type = serializers.ChoiceField(
-        choices=["html", "markdown"],
-        label=_("Body type"),
-        required=False,
-        default="html",
-    )
-    format = serializers.ChoiceField(
-        choices=["pdf", "docx"],
-        label=_("Format"),
-        required=False,
-        default="pdf",
-    )
-
-
 class InvitationSerializer(serializers.ModelSerializer):
     """Serialize invitations."""
 

src/backend/core/api/viewsets.py

@@ -2109,64 +2109,6 @@ class DocumentAccessViewSet(
         )
 
 
-class TemplateViewSet(
-    drf.mixins.RetrieveModelMixin,
-    viewsets.GenericViewSet,
-):
-    """Template ViewSet"""
-
-    filter_backends = [drf.filters.OrderingFilter]
-    permission_classes = [
-        permissions.IsAuthenticatedOrSafe,
-        permissions.ResourceWithAccessPermission,
-    ]
-    throttle_scope = "template"
-    ordering = ["-created_at"]
-    ordering_fields = ["created_at", "updated_at", "title"]
-    serializer_class = serializers.TemplateSerializer
-    queryset = models.Template.objects.all()
-
-    def get_queryset(self):
-        """Custom queryset to get user related templates."""
-        queryset = super().get_queryset()
-        user = self.request.user
-
-        if not user.is_authenticated:
-            return queryset
-
-        user_roles_query = (
-            models.TemplateAccess.objects.filter(
-                db.Q(user=user) | db.Q(team__in=user.teams),
-                template_id=db.OuterRef("pk"),
-            )
-            .values("template")
-            .annotate(roles_array=ArrayAgg("role"))
-            .values("roles_array")
-        )
-        return queryset.annotate(user_roles=db.Subquery(user_roles_query)).distinct()
-
-    def list(self, request, *args, **kwargs):
-        """Restrict templates returned by the list endpoint"""
-        queryset = self.filter_queryset(self.get_queryset())
-        user = self.request.user
-        if user.is_authenticated:
-            queryset = queryset.filter(
-                db.Q(accesses__user=user)
-                | db.Q(accesses__team__in=user.teams)
-                | db.Q(is_public=True)
-            )
-        else:
-            queryset = queryset.filter(is_public=True)
-
-        page = self.paginate_queryset(queryset)
-        if page is not None:
-            serializer = self.get_serializer(page, many=True)
-            return self.get_paginated_response(serializer.data)
-
-        serializer = self.get_serializer(queryset, many=True)
-        return drf.response.Response(serializer.data)
-
-
 class InvitationViewset(
     drf.mixins.CreateModelMixin,
     drf.mixins.ListModelMixin,