add usecase dashboard related model and schema

Author: Deepthi-Chand

api/models/UseCaseDashboard.py

@@ -0,0 +1,24 @@
+from django.db import models
+
+
+class UseCaseDashboard(models.Model):
+    """
+    Model to store dashboard information for usecases.
+    Each usecase can have multiple dashboards with names and links.
+    """
+
+    id = models.AutoField(primary_key=True)
+    name = models.CharField(max_length=200, blank=False, null=False)
+    link = models.URLField(blank=False, null=False)
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
+    usecase = models.ForeignKey(
+        "api.UseCase", on_delete=models.CASCADE, related_name="dashboards"
+    )
+
+    class Meta:
+        db_table = "usecase_dashboard"
+        ordering = ["created"]
+
+    def __str__(self):
+        return f"{self.name} - {self.usecase.title if self.usecase else 'No Usecase'}"

api/models/__init__.py

@@ -19,5 +19,6 @@
 from api.models.Sector import Sector
 from api.models.SerializableJSONField import SerializableJSONField
 from api.models.UseCase import UseCase
+from api.models.UseCaseDashboard import UseCaseDashboard
 from api.models.UseCaseMetadata import UseCaseMetadata
 from api.models.UseCaseOrganizationRelationship import UseCaseOrganizationRelationship

api/schema/schema.py

@@ -19,6 +19,7 @@
 import api.schema.sector_schema
 import api.schema.stats_schema
 import api.schema.tags_schema
+import api.schema.usecase_dashboard_schema
 import api.schema.usecase_schema
 import api.schema.user_schema
 from api.models import Resource, Tag
@@ -53,6 +54,7 @@ def tags(self, info: Info) -> List[TypeTag]:
     "Query",
     (
         DefaultQuery,
+        api.schema.usecase_dashboard_schema.Query,
         api.schema.dataset_schema.Query,
         api.schema.resource_schema.Query,
         api.schema.access_model_schema.Query,
@@ -72,6 +74,7 @@ def tags(self, info: Info) -> List[TypeTag]:
 Mutation = merge_types(
     "Mutation",
     (
+        api.schema.usecase_dashboard_schema.Mutation,
         api.schema.dataset_schema.Mutation,
         api.schema.resource_schema.Mutation,
         api.schema.access_model_schema.Mutation,

api/schema/usecase_dashboard_schema.py

@@ -0,0 +1,183 @@
+"""Schema definitions for usecase dashboards."""
+
+from typing import List, Optional
+
+import strawberry
+import strawberry_django
+from strawberry.types import Info
+from strawberry_django.pagination import OffsetPaginationInput
+
+from api.models import UseCase, UseCaseDashboard
+from api.schema.base_mutation import BaseMutation
+from api.types.type_usecase_dashboard import (
+    TypeUseCaseDashboard,
+    UseCaseDashboardFilter,
+    UseCaseDashboardOrder,
+)
+from api.utils.graphql_telemetry import trace_resolver
+from authorization.permissions import IsAuthenticated
+
+
+@strawberry.input
+class UseCaseDashboardInput:
+    """Input type for usecase dashboard creation."""
+
+    name: str
+    link: str
+
+
+@strawberry.input
+class AddUseCaseDashboardsInput:
+    """Input for adding multiple dashboards to a usecase."""
+
+    usecase_id: int
+    dashboards: List[UseCaseDashboardInput]
+
+
+@strawberry.type
+class UseCaseDashboardMutationResponse:
+    """Response type for usecase dashboard mutations."""
+
+    dashboards: Optional[List[TypeUseCaseDashboard]] = None
+    success: bool = False
+    message: str = ""
+
+
+class Mutation:
+    """UseCaseDashboard mutations."""
+
+    @BaseMutation.mutation(
+        permission_classes=[IsAuthenticated],
+        trace_name="add_usecase_dashboards",
+        trace_attributes={"component": "usecase_dashboard"},
+        track_activity={
+            "verb": "created",
+            "get_data": lambda result, **kwargs: {
+                "usecase_id": str(kwargs.get("input").usecase_id),
+                "dashboard_count": len(result),
+            },
+        },
+    )
+    def add_usecase_dashboards(
+        self, info: Info, input: AddUseCaseDashboardsInput
+    ) -> UseCaseDashboardMutationResponse:
+        """Add multiple dashboards to a usecase."""
+        try:
+            # Check if usecase exists
+            usecase = UseCase.objects.get(id=input.usecase_id)
+
+            # Create dashboards
+            created_dashboards = []
+            for dashboard_input in input.dashboards:
+                dashboard = UseCaseDashboard.objects.create(
+                    name=dashboard_input.name,
+                    link=dashboard_input.link,
+                    usecase=usecase,
+                )
+                created_dashboards.append(dashboard)
+
+            return UseCaseDashboardMutationResponse(
+                dashboards=[
+                    TypeUseCaseDashboard.from_django(d) for d in created_dashboards
+                ],
+                success=True,
+                message=f"Added {len(created_dashboards)} dashboards to usecase",
+            )
+        except UseCase.DoesNotExist:
+            raise Exception(f"Usecase with ID {input.usecase_id} does not exist")
+        except Exception as e:
+            raise Exception(f"Failed to add dashboards: {str(e)}")
+
+    @BaseMutation.mutation(
+        permission_classes=[IsAuthenticated],
+        trace_name="delete_usecase_dashboard",
+        trace_attributes={"component": "usecase_dashboard"},
+        track_activity={
+            "verb": "deleted",
+            "get_data": lambda result, **kwargs: {
+                "dashboard_id": str(kwargs.get("id")),
+            },
+        },
+    )
+    def delete_usecase_dashboard(
+        self, info: Info, id: int
+    ) -> UseCaseDashboardMutationResponse:
+        """Delete a usecase dashboard."""
+        try:
+            dashboard = UseCaseDashboard.objects.get(id=id)
+            dashboard.delete()
+            return UseCaseDashboardMutationResponse(
+                success=True,
+                message=f"Dashboard with ID {id} deleted successfully",
+            )
+        except UseCaseDashboard.DoesNotExist:
+            raise Exception(f"Dashboard with ID {id} does not exist")
+        except Exception as e:
+            raise Exception(f"Failed to delete dashboard: {str(e)}")
+
+
+class Query:
+    """UseCaseDashboard queries."""
+
+    @strawberry_django.field(
+        filters=UseCaseDashboardFilter,
+        pagination=True,
+        order=UseCaseDashboardOrder,
+    )
+    @trace_resolver(
+        name="get_usecase_dashboards_all", attributes={"component": "usecase_dashboard"}
+    )
+    def usecase_dashboards_all(
+        self,
+        info: Info,
+        filters: UseCaseDashboardFilter = strawberry.UNSET,
+        pagination: OffsetPaginationInput = strawberry.UNSET,
+        order: UseCaseDashboardOrder = strawberry.UNSET,
+    ) -> list[TypeUseCaseDashboard]:
+        """Get all usecase dashboards."""
+        queryset = UseCaseDashboard.objects.all()
+
+        if filters is not strawberry.UNSET:
+            queryset = strawberry_django.filters.apply(filters, queryset, info)
+
+        if order is not strawberry.UNSET:
+            queryset = strawberry_django.ordering.apply(order, queryset, info)
+
+        dashboard_instances = list(queryset)
+
+        if pagination is not strawberry.UNSET:
+            offset = pagination.offset if pagination.offset is not None else 0
+            limit = pagination.limit
+
+            if limit is not None:
+                dashboard_instances = dashboard_instances[offset : offset + limit]
+            else:
+                dashboard_instances = dashboard_instances[offset:]
+
+        return [
+            TypeUseCaseDashboard.from_django(instance)
+            for instance in dashboard_instances
+        ]
+
+    @strawberry_django.field
+    @trace_resolver(
+        name="get_usecase_dashboards", attributes={"component": "usecase_dashboard"}
+    )
+    def usecase_dashboards(
+        self, info: Info, usecase_id: int
+    ) -> list[TypeUseCaseDashboard]:
+        """Get dashboards for a specific usecase."""
+        try:
+            # Check if usecase exists
+            usecase = UseCase.objects.get(id=usecase_id)
+
+            # Get dashboards for the usecase
+            dashboards = UseCaseDashboard.objects.filter(usecase=usecase)
+
+            return [
+                TypeUseCaseDashboard.from_django(dashboard) for dashboard in dashboards
+            ]
+        except UseCase.DoesNotExist:
+            raise Exception(f"Usecase with ID {usecase_id} does not exist")
+        except Exception as e:
+            raise Exception(f"Failed to get usecase dashboards: {str(e)}")

api/types/type_usecase_dashboard.py

@@ -0,0 +1,40 @@
+"""Type definitions for UseCaseDashboard model."""
+
+from typing import Optional
+
+import strawberry
+import strawberry_django
+from strawberry import auto
+from strawberry_django.filters import FilterLookup
+
+from api.models import UseCaseDashboard
+from api.types.base_type import BaseType
+
+
+@strawberry_django.type(UseCaseDashboard)
+class TypeUseCaseDashboard(BaseType):
+    """Type for UseCaseDashboard model."""
+
+    id: auto
+    name: auto
+    link: auto
+    created: auto
+    modified: auto
+    usecase_id: auto
+
+
+@strawberry.input
+class UseCaseDashboardFilter:
+    """Filter for UseCaseDashboard queries."""
+
+    id: Optional[FilterLookup[int]] = strawberry.UNSET
+    name: Optional[FilterLookup[str]] = strawberry.UNSET
+    usecase_id: Optional[FilterLookup[int]] = strawberry.UNSET
+
+
+@strawberry.input
+class UseCaseDashboardOrder:
+    """Order for UseCaseDashboard queries."""
+
+    name: Optional[str] = strawberry.UNSET
+    created: Optional[str] = strawberry.UNSET