fix(UI): show domain full path and fix sorting

backend/core/models.py

@@ -2322,7 +2322,7 @@ def overall_compliance(self):
         return round(count * 100 / total)
 
     def __str__(self):
-        return self.folder.name + "/" + self.name
+        return f"{self.folder}/{self.name}"
 
 
 class SecurityException(NameDescriptionMixin, FolderMixin, PublishInRootFolderMixin):

backend/core/serializers.py

@@ -266,6 +266,7 @@ class PerimeterReadSerializer(BaseModelSerializer):
     folder = FieldsRelatedField()
     lc_status = serializers.CharField(source="get_lc_status_display")
     default_assignee = FieldsRelatedField(many=True)
+    str = serializers.CharField(source="__str__", read_only=True)
 
     class Meta:
         model = Perimeter
@@ -1415,6 +1416,7 @@ class FolderReadSerializer(BaseModelSerializer):
     filtering_labels = FieldsRelatedField(many=True)
 
     content_type = serializers.CharField(source="get_content_type_display")
+    str = serializers.CharField(source="__str__", read_only=True)
 
     class Meta:
         model = Folder

backend/core/views.py

@@ -1120,9 +1120,6 @@ def get(self, request, format=None):
         return Response(content_types)
 
 
-# Risk Assessment
-
-
 class PerimeterFilter(GenericFilterSet):
     folder = df.ModelMultipleChoiceFilter(
         queryset=Folder.objects.all(),
@@ -1136,15 +1133,91 @@ class Meta:
         fields = ["name", "folder", "lc_status", "campaigns"]
 
 
+class PathAwareOrderingFilter(filters.OrderingFilter):
+    """
+    Ordering filter that supports Python-side ordering for configured path fields.
+
+    - path_fields: fields that require Python-side ordering
+    - related_field: the related FK to follow for path-aware sorting (optional)
+    """
+
+    path_fields: set[str] = set()
+    related_field: str | None = None  # override per view if needed
+
+    def filter_queryset(self, request, queryset, view):
+        ordering = self.get_ordering(request, queryset, view)
+        if not ordering:
+            return queryset
+
+        # Use view-defined path_fields if not explicitly set in the filter
+        path_fields = self.path_fields or getattr(view, "path_ordering_fields", set())
+        if not path_fields:
+            return super().filter_queryset(request, queryset, view)
+
+        # Normalize ordering fields
+        normalized_ordering = [f.lstrip("-") for f in ordering]
+        if not any(f in path_fields for f in normalized_ordering):
+            return super().filter_queryset(request, queryset, view)
+
+        # Optional related field for path-aware sorting
+        related_field = getattr(view, "path_related_field", "folder")
+        if related_field and hasattr(queryset.model, related_field):
+            queryset = queryset.select_related(related_field)
+
+        data = list(queryset)
+
+        # Build full path string
+        def full_path(obj):
+            if isinstance(obj, Folder):
+                return str(obj)
+            folder = getattr(obj, related_field, None) if related_field else None
+            if folder is None:
+                return ""
+            # Use get_folder_full_path if available
+            if hasattr(folder, "get_folder_full_path"):
+                items = folder.get_folder_full_path(include_root=False)
+                names = [getattr(f, "name", "") or "" for f in items]
+                return " / ".join(names) if names else (folder.name or "")
+            return getattr(folder, "name", "") or ""
+
+        # Key function for sorting
+        def key_for_field(obj, field):
+            if field not in path_fields:
+                value = getattr(obj, field, "")
+                return value.casefold() if isinstance(value, str) else value
+            # Path-aware field
+            path_key = full_path(obj).casefold()
+            name_key = (getattr(obj, "name", "") or "").casefold()
+            return (path_key, name_key)
+
+        # Apply multi-field stable sort in reverse order
+        for field in reversed(ordering):
+            reverse = field.startswith("-")
+            field_name = field.lstrip("-")
+            data.sort(
+                key=lambda obj, f=field_name: key_for_field(obj, f), reverse=reverse
+            )
+
+        return data
+
+
 class PerimeterViewSet(BaseModelViewSet):
     """
     API endpoint that allows perimeters to be viewed or edited.
     """
 
     model = Perimeter
     filterset_class = PerimeterFilter
-    search_fields = ["name", "ref_id", "description"]
+    search_fields = ["name", "folder__name", "ref_id", "description"]
     filterset_fields = ["name", "folder", "campaigns"]
+    filter_backends = [
+        DjangoFilterBackend,
+        PathAwareOrderingFilter,
+        filters.SearchFilter,
+    ]
+    ordering_fields = ["name", "folder", "str", "description", "default_assignee"]
+    path_ordering_fields = {"str"}
+    path_fields = {"str"}
 
     @method_decorator(cache_page(60 * LONG_CACHE_TTL))
     @action(detail=False, name="Get status choices")
@@ -5456,66 +5529,13 @@ def destroy(self, request, *args, **kwargs):
         return super().destroy(request, *args, **kwargs)
 
 
-class UserGroupOrderingFilter(filters.OrderingFilter):
+class UserGroupOrderingFilter(PathAwareOrderingFilter):
     """
     Custom ordering filter:
-    - Performs in-memory (Python) sorting only for `localization_dict`.
-    - The sort key is a tuple: (folder full_path OR folder.name, object.name).
-    - Supports `-localization_dict` for descending order.
-    - For all other fields, it falls back to standard SQL ordering.
+    - Supports `localization_dict` via PathAwareOrderingFilter
     """
 
-    def filter_queryset(self, request, queryset, view):
-        ordering = self.get_ordering(request, queryset, view)
-        if not ordering:
-            return queryset
-
-        # Special case: in-memory sorting for `localization_dict`
-        if len(ordering) == 1 and ordering[0].lstrip("-") == "localization_dict":
-            desc = ordering[0].startswith("-")
-
-            # Optimize DB access: fetch the related folder in one query
-            queryset = queryset.select_related("folder")
-
-            # Materialize queryset into a list to sort in Python
-            data = list(queryset)
-
-            def full_path_or_name(folder):
-                """
-                Build a string key from the folder:
-                - Prefer the full path (names of all parent folders + current).
-                - Fall back to the folder's name if no path is available.
-                """
-                if folder is None:
-                    return ""
-
-                path_list = getattr(folder, "get_folder_full_path", None)
-                if callable(path_list):
-                    items = folder.get_folder_full_path(include_root=False)
-                    names = [getattr(f, "name", "") or "" for f in items]
-                    if names:
-                        return "/".join(names)
-
-                # Fallback: just the folder name
-                return getattr(folder, "name", "") or ""
-
-            def key_func(obj):
-                # Get the folder from the object
-                folder = getattr(obj, "folder", None)
-                # If you want to be more robust, you could use:
-                # from yourapp.models import Folder
-                # folder = Folder.get_folder(obj)
-
-                path_key = full_path_or_name(folder).casefold()
-                name_key = (getattr(obj, "name", "") or "").casefold()
-                return (path_key, name_key)
-
-            # Perform stable sort, reverse if `-localization_dict`
-            data.sort(key=key_func, reverse=desc)
-            return data
-
-        # Default case: fall back to SQL ordering
-        return super().filter_queryset(request, queryset, view)
+    path_fields = {"localization_dict"}
 
 
 class UserGroupViewSet(BaseModelViewSet):
@@ -5583,7 +5603,16 @@ class FolderViewSet(BaseModelViewSet):
     model = Folder
     filterset_class = FolderFilter
     search_fields = ["name"]
+    filter_backends = [
+        DjangoFilterBackend,
+        PathAwareOrderingFilter,
+        filters.SearchFilter,
+    ]
+    ordering_fields = ["name", "str", "parent_folder", "description", "content_type"]
     batch_size = 100  # Configurable batch size for processing domain import
+    path_ordering_fields = {"str"}
+    path_fields = {"str"}
+    path_related_fields = "parent_folder"
 
     def perform_create(self, serializer):
         """

backend/iam/models.py

@@ -132,7 +132,11 @@ class Meta:
         verbose_name_plural = _("Folders")
 
     def __str__(self) -> str:
-        return self.name.__str__()
+        path = self.get_folder_full_path(include_root=False)
+        names = [getattr(folder, "name", "") or "" for folder in path]
+        cleaned = [name for name in names if name]
+        display = "/".join(cleaned) if cleaned else (self.name or "")
+        return display or ""
 
     def get_sub_folders(self) -> Generator[Self, None, None]:
         """Return the list of subfolders"""
@@ -381,15 +385,15 @@ class Meta:
 
     def __str__(self) -> str:
         if self.builtin:
-            return f"{self.folder.name} - {BUILTIN_USERGROUP_CODENAMES.get(self.name)}"
-        return f"{self.folder.name} - {self.name}"
+            return f"{self.folder} - {BUILTIN_USERGROUP_CODENAMES.get(self.name)}"
+        return f"{self.folder} - {self.name}"
 
     def get_name_display(self) -> str:
         return self.name
 
     def get_localization_dict(self) -> dict:
         return {
-            "folder": self.folder.name,
+            "folder": str(self.folder),
             "role": BUILTIN_USERGROUP_CODENAMES.get(self.name)
             if self.builtin
             else self.name,

enterprise/backend/enterprise_core/views.py

@@ -250,13 +250,34 @@ def get(self, request):
             return Response({"status": "expired", "days_expired": days_expired})
 
 
+class RoleOrderingFilter(filters.OrderingFilter):
+    """
+    Order roles by their display name (sensitive to builtin translations).
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        ordering = self.get_ordering(request, queryset, view)
+        if not ordering:
+            return queryset
+
+        if len(ordering) == 1 and ordering[0].lstrip("-") == "name":
+            reverse = ordering[0].startswith("-")
+            data = list(queryset)
+            data.sort(key=lambda role: str(role).casefold(), reverse=reverse)
+            return data
+
+        return super().filter_queryset(request, queryset, view)
+
+
 class RoleViewSet(BaseModelViewSet):
     """
     API endpoint that allows roles to be viewed or edited
     """
 
     model = Role
     ordering = ["builtin", "name"]
+    ordering_fields = ["name"]
+    filter_backends = [DjangoFilterBackend, RoleOrderingFilter, filters.SearchFilter]
 
     def perform_create(self, serializer):
         """

frontend/src/lib/components/DetailView/DetailView.svelte

@@ -435,7 +435,9 @@
 											? key.replace('_', '-') + '-field-value'
 											: null}
 									>
-										{#if value !== null && value !== undefined && value !== ''}
+										{#if key === 'name' && (data.model?.name === 'folder' || data.urlModel === 'folders') && data.data?.str}
+											{data.data.str}
+										{:else if value !== null && value !== undefined && value !== ''}
 											{#if key === 'asset_class'}
 												<!-- Special case for asset_class - Always translate the value -->
 												{#if typeof value === 'object' && (value.str || value.name)}

frontend/src/lib/utils/crud.ts

@@ -228,7 +228,7 @@ export const URL_MODEL_MAP: ModelMap = {
 			{ field: 'ebios_rm_study', urlModel: 'ebios-rm' }
 		],
 		reverseForeignKeyFields: [{ field: 'risk_assessment', urlModel: 'risk-scenarios' }],
-		selectFields: [{ field: 'status' }, { field: 'risk_tolerance', valueType: 'number' }],
+		selectFields: [{ field: 'status' }],
 		filters: [{ field: 'perimeter' }, { field: 'auditor' }, { field: 'status' }]
 	},
 	'risk-assessment_duplicate': {

frontend/src/lib/utils/table.ts

@@ -119,6 +119,16 @@ export const DOMAIN_FILTER: ListViewFilterConfig = {
 	}
 };
 
+export const PARENT_DOMAIN_FILTER: ListViewFilterConfig = {
+	component: AutocompleteSelect,
+	props: {
+		optionsEndpoint: 'folders?content_type=DO&content_type=GL',
+		optionsLabelField: 'str',
+		label: 'parent_domain',
+		multiple: true
+	}
+};
+
 export const LABELS_FILTER: ListViewFilterConfig = {
 	component: AutocompleteSelect,
 	props: {
@@ -1194,16 +1204,17 @@ export const VULNERABILITY_SEVERITY_FILTER: ListViewFilterConfig = {
 
 export const listViewFields = {
 	folders: {
-		head: ['name', 'description', 'contentType', 'parentDomain', 'labels'],
-		body: ['name', 'description', 'content_type', 'parent_folder', 'filtering_labels'],
+		head: ['name', 'description', 'contentType', 'labels'],
+		body: ['str', 'description', 'content_type', 'filtering_labels'],
 		filters: {
+			parent_folder: PARENT_DOMAIN_FILTER,
 			content_type: CONTENT_TYPE_FILTER,
 			filtering_labels: LABELS_FILTER
 		}
 	},
 	perimeters: {
-		head: ['ref_id', 'name', 'description', 'defaultAssignee', 'domain'],
-		body: ['ref_id', 'name', 'description', 'default_assignee', 'folder'],
+		head: ['ref_id', 'name', 'description', 'defaultAssignee'],
+		body: ['ref_id', 'str', 'description', 'default_assignee'],
 		filters: {
 			folder: DOMAIN_FILTER,
 			lc_status: PERIMETER_STATUS_FILTER

frontend/tests/functional/detailed/ebios-rm.test.ts

@@ -590,6 +590,7 @@ test('ebios rm study', async ({
 
 	await test.step('workshop 5', async () => {
 		await page.getByRole('button', { name: ' Step 1 Generate the risk' }).click();
+		await page.waitForTimeout(3000);
 		await riskAssessmentsPage.form.fill({
 			name: 'test-risk-assessment-ebios-rm',
 			perimeter: `${vars.folderName}/${vars.perimeterName}`

frontend/tests/utils/test-utils.ts

@@ -552,6 +552,7 @@ export class TestContent {
 				displayName: 'Perimeters',
 				modelName: 'perimeter',
 				build: {
+					str: `${vars.folderName}/${vars.perimeterName}`,
 					name: vars.perimeterName,
 					description: vars.description,
 					folder: vars.folderName,