add SDG model and corresponding schema

Author: Deepthi-Chand

api/models/Collaborative.py

@@ -40,6 +40,7 @@ class Collaborative(models.Model):
     sectors = models.ManyToManyField(
         "api.Sector", blank=True, related_name="collaboratives"
     )
+    sdgs = models.ManyToManyField("api.SDG", blank=True, related_name="collaboratives")
     contributors = models.ManyToManyField(
         "authorization.User", blank=True, related_name="contributed_collaboratives"
     )
@@ -71,5 +72,9 @@ def sectors_indexing(self):
     def tags_indexing(self):
         return [tag.value for tag in self.tags.all()]  # type: ignore
 
+    @property
+    def sdgs_indexing(self):
+        return [sdg.code for sdg in self.sdgs.all()]  # type: ignore
+
     class Meta:
         db_table = "collaborative"

api/models/SDG.py

@@ -0,0 +1,31 @@
+import uuid
+from typing import Any
+
+from django.db import models
+from django.utils.text import slugify
+
+
+class SDG(models.Model):
+    """Model for Sustainable Development Goals (SDGs)."""
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=100, unique=True, null=False, blank=False)
+    code = models.CharField(
+        max_length=10, unique=True, null=False, blank=False
+    )  # e.g., "SDG1", "SDG2"
+    description = models.TextField(null=True, blank=True)
+    slug = models.SlugField(max_length=100, null=True, blank=False, unique=True)
+
+    def save(self, *args: Any, **kwargs: Any) -> None:
+        if not self.slug:
+            self.slug = slugify(self.name)
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return f"{self.code} - {self.name}"
+
+    class Meta:
+        db_table = "sdg"
+        verbose_name = "SDG"
+        verbose_name_plural = "SDGs"
+        ordering = ["code"]

api/models/__init__.py

@@ -22,6 +22,7 @@
 from api.models.ResourceChartImage import ResourceChartImage
 from api.models.ResourceMetadata import ResourceMetadata
 from api.models.ResourceSchema import ResourceSchema
+from api.models.SDG import SDG
 from api.models.Sector import Sector
 from api.models.SerializableJSONField import SerializableJSONField
 from api.models.UseCase import UseCase

api/schema/collaborative_schema.py

@@ -16,6 +16,7 @@
 from strawberry_django.pagination import OffsetPaginationInput
 
 from api.models import (
+    SDG,
     Collaborative,
     CollaborativeMetadata,
     CollaborativeOrganizationRelationship,
@@ -64,6 +65,7 @@ class UpdateCollaborativeMetadataInput:
     metadata: List[CollaborativeMetadataItemType]
     tags: Optional[List[str]]
     sectors: List[uuid.UUID]
+    sdgs: Optional[List[uuid.UUID]]
 
 
 @strawberry_django.partial(Collaborative, fields="__all__", exclude=["datasets"])
@@ -77,6 +79,7 @@ class CollaborativeInputPartial:
     platform_url: Optional[str] = None
     tags: Optional[List[str]] = None
     sectors: Optional[List[uuid.UUID]] = None
+    sdgs: Optional[List[uuid.UUID]] = None
     started_on: Optional[datetime.date] = None
     completed_on: Optional[datetime.date] = None
 
@@ -219,6 +222,18 @@ def _update_collaborative_sectors(
     collaborative.save()
 
 
+@trace_resolver(
+    name="update_collaborative_sdgs", attributes={"component": "collaborative"}
+)
+def _update_collaborative_sdgs(
+    collaborative: Collaborative, sdgs: List[uuid.UUID]
+) -> None:
+    sdgs_objs = SDG.objects.filter(id__in=sdgs)
+    collaborative.sdgs.clear()
+    collaborative.sdgs.add(*sdgs_objs)
+    collaborative.save()
+
+
 @trace_resolver(
     name="add_update_collaborative_metadata",
     attributes={"component": "collaborative", "operation": "mutation"},
@@ -363,6 +378,8 @@ def add_update_collaborative_metadata(
             _update_collaborative_tags(collaborative, update_metadata_input.tags)
         _add_update_collaborative_metadata(collaborative, metadata_input)
         _update_collaborative_sectors(collaborative, update_metadata_input.sectors)
+        if update_metadata_input.sdgs is not None:
+            _update_collaborative_sdgs(collaborative, update_metadata_input.sdgs)
         return TypeCollaborative.from_django(collaborative)
 
     @strawberry_django.mutation(handle_django_errors=False)

api/schema/schema.py

@@ -17,6 +17,7 @@
 import api.schema.resource_chart_schema
 import api.schema.resource_schema
 import api.schema.resoure_chart_image_schema
+import api.schema.sdg_schema
 import api.schema.sector_schema
 import api.schema.stats_schema
 import api.schema.tags_schema
@@ -59,6 +60,7 @@ def tags(self, info: Info) -> List[TypeTag]:
         api.schema.dataset_schema.Query,
         api.schema.resource_schema.Query,
         api.schema.access_model_schema.Query,
+        api.schema.sdg_schema.Query,
         api.schema.sector_schema.Query,
         api.schema.resource_chart_schema.Query,
         api.schema.stats_schema.Query,
@@ -80,6 +82,7 @@ def tags(self, info: Info) -> List[TypeTag]:
         api.schema.dataset_schema.Mutation,
         api.schema.resource_schema.Mutation,
         api.schema.access_model_schema.Mutation,
+        api.schema.sdg_schema.Mutation,
         api.schema.sector_schema.Mutation,
         api.schema.resource_chart_schema.Mutation,
         api.schema.usecase_schema.Mutation,

api/schema/sdg_schema.py

@@ -0,0 +1,114 @@
+import uuid
+from typing import Optional
+
+import strawberry
+import strawberry_django
+from strawberry.types import Info
+from strawberry_django.pagination import OffsetPaginationInput
+
+from api.models import SDG
+from api.types.type_sdg import SDGFilter, SDGOrder, TypeSDG
+
+
+@strawberry.input
+class SDGInput:
+    name: str
+    code: str
+    description: Optional[str] = None
+
+
+@strawberry_django.partial(SDG)
+class SDGInputPartial:
+    id: uuid.UUID
+    name: Optional[str] = None
+    code: Optional[str] = None
+    description: Optional[str] = None
+    slug: Optional[str] = None
+
+
+@strawberry.type(name="Query")
+class Query:
+    sdgs: list[TypeSDG] = strawberry_django.field()
+
+    @strawberry_django.field
+    def sdg(self, info: Info, id: uuid.UUID) -> Optional[TypeSDG]:
+        """Get SDG by ID."""
+        try:
+            sdg = SDG.objects.get(id=id)
+            return TypeSDG.from_django(sdg)
+        except SDG.DoesNotExist:
+            raise ValueError(f"SDG with ID {id} does not exist.")
+
+    @strawberry_django.field(
+        filters=SDGFilter,
+        pagination=True,
+        order=SDGOrder,
+    )
+    def all_sdgs(
+        self,
+        info: Info,
+        filters: Optional[SDGFilter] = strawberry.UNSET,
+        pagination: Optional[OffsetPaginationInput] = strawberry.UNSET,
+        order: Optional[SDGOrder] = strawberry.UNSET,
+    ) -> list[TypeSDG]:
+        """Get all SDGs."""
+        queryset = SDG.objects.all()
+
+        # Apply filters if provided
+        if filters is not strawberry.UNSET:
+            queryset = strawberry_django.filters.apply(filters, queryset, info)
+
+        # Apply ordering if provided
+        if order is not strawberry.UNSET:
+            queryset = strawberry_django.ordering.apply(order, queryset, info)
+
+        # Apply pagination if provided
+        if pagination is not strawberry.UNSET:
+            queryset = strawberry_django.pagination.apply(pagination, queryset)
+
+        return [TypeSDG.from_django(instance) for instance in queryset]
+
+
+@strawberry.type
+class Mutation:
+    @strawberry_django.mutation(handle_django_errors=True)
+    def create_sdg(self, info: Info, input: SDGInput) -> TypeSDG:
+        """Create a new SDG."""
+        sdg = SDG(
+            name=input.name,
+            code=input.code,
+            description=input.description,
+        )
+        sdg.save()
+        return TypeSDG.from_django(sdg)
+
+    @strawberry_django.mutation(handle_django_errors=True)
+    def update_sdg(self, info: Info, input: SDGInputPartial) -> Optional[TypeSDG]:
+        """Update an existing SDG."""
+        try:
+            sdg = SDG.objects.get(id=input.id)
+
+            # Update fields if provided
+            if input.name is not None:
+                sdg.name = input.name
+            if input.code is not None:
+                sdg.code = input.code
+            if input.description is not None:
+                sdg.description = input.description
+            if input.slug is not None:
+                sdg.slug = input.slug
+
+            sdg.save()
+            return TypeSDG.from_django(sdg)
+        except SDG.DoesNotExist:
+            raise ValueError(f"SDG with ID {input.id} does not exist.")
+
+    @strawberry_django.mutation(handle_django_errors=False)
+    def delete_sdg(self, info: Info, sdg_id: uuid.UUID) -> bool:
+        """Delete an SDG."""
+        try:
+            sdg = SDG.objects.get(id=sdg_id)
+            sdg.delete()
+            return True
+        except SDG.DoesNotExist:
+            raise ValueError(f"SDG with ID {sdg_id} does not exist.")

api/types/type_collaborative.py

@@ -19,6 +19,7 @@
 )
 from api.types.type_dataset import TypeDataset, TypeTag
 from api.types.type_organization import TypeOrganization
+from api.types.type_sdg import TypeSDG
 from api.types.type_sector import TypeSector
 from api.types.type_usecase import TypeUseCase
 from api.utils.enums import CollaborativeStatus, OrganizationRelationshipType
@@ -135,6 +136,17 @@ def sectors(self) -> Optional[List["TypeSector"]]:
         except Exception:
             return []
 
+    @strawberry.field(description="Get SDGs associated with this collaborative.")
+    def sdgs(self) -> Optional[List["TypeSDG"]]:
+        """Get SDGs associated with this collaborative."""
+        try:
+            queryset = self.sdgs.all()  # type: ignore
+            if not queryset.exists():
+                return []
+            return TypeSDG.from_django_list(queryset)
+        except Exception:
+            return []
+
     @strawberry.field(description="Get tags associated with this collaborative.")
     def tags(self) -> Optional[List["TypeTag"]]:
         """Get tags associated with this collaborative."""

api/types/type_sdg.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+import strawberry
+import strawberry_django
+from strawberry import auto
+
+from api.models import SDG
+from api.types.base_type import BaseType
+
+
+@strawberry_django.filter(SDG)
+class SDGFilter:
+    """Filter class for SDG model."""
+
+    id: auto
+    code: auto
+    name: auto
+
+
+@strawberry_django.order(SDG)
+class SDGOrder:
+    """Order class for SDG model."""
+
+    code: auto
+    name: auto
+
+
+@strawberry_django.type(
+    SDG,
+    pagination=True,
+    fields="__all__",
+    filters=SDGFilter,
+    order=SDGOrder,  # type: ignore
+)
+class TypeSDG(BaseType):
+    """GraphQL type for SDG model."""
+
+    pass

api/utils/enums.py

@@ -40,6 +40,7 @@ class MetadataModels(models.TextChoices):
     DATASET = "DATASET"
     RESEOURCE = "RESOURCE"
     USECASE = "USECASE"
+    COLLABORATIVE = "COLLABORATIVE"
 
 
 class MetadataStandards(models.TextChoices):