add collaborative feature

Author: Deepthi-Chand

api/activities/collaborative.py

@@ -0,0 +1,212 @@
+from typing import Any, Dict, Optional
+
+from django.http import HttpRequest
+
+from api.activities.base import track_model_activity
+from api.models.Collaborative import Collaborative
+from authorization.models import User
+
+
+def track_collaborative_created(
+    user: User, collaborative: Collaborative, request: Optional[HttpRequest] = None
+) -> None:
+    """
+    Track when a collaborative is created.
+    """
+    track_model_activity(
+        actor=user,
+        verb="created",
+        model_instance=collaborative,
+        target=collaborative.organization if collaborative.organization else None,
+        request=request,
+        extra_data={
+            "collaborative_title": collaborative.title,
+            "collaborative_id": str(collaborative.id),
+            "organization_id": (
+                str(collaborative.organization.id)
+                if collaborative.organization
+                else None
+            ),
+            "organization_name": (
+                collaborative.organization.name if collaborative.organization else None
+            ),
+        },
+    )
+
+
+def track_collaborative_updated(
+    user: User,
+    collaborative: Collaborative,
+    updated_fields: Optional[Dict[str, Any]] = None,
+    request: Optional[HttpRequest] = None,
+) -> None:
+    """
+    Track when a collaborative is updated.
+
+    Args:
+        user: The user performing the update
+        collaborative: The collaborative being updated
+        updated_fields: Dictionary of fields that were updated
+        request: The current HTTP request
+    """
+    track_model_activity(
+        actor=user,
+        verb="updated",
+        model_instance=collaborative,
+        target=collaborative.organization if collaborative.organization else None,
+        request=request,
+        extra_data={
+            "collaborative_title": collaborative.title,
+            "collaborative_id": str(collaborative.id),
+            "updated_fields": updated_fields or {},
+        },
+    )
+
+
+def track_collaborative_published(
+    user: User, collaborative: Collaborative, request: Optional[HttpRequest] = None
+) -> None:
+    """
+    Track when a collaborative is published (status changed to PUBLISHED).
+    """
+    track_model_activity(
+        actor=user,
+        verb="published",
+        model_instance=collaborative,
+        target=collaborative.organization if collaborative.organization else None,
+        request=request,
+        extra_data={
+            "collaborative_title": collaborative.title,
+            "collaborative_id": str(collaborative.id),
+        },
+    )
+
+
+def track_collaborative_deleted(
+    user: User,
+    collaborative_id: str,
+    collaborative_title: str,
+    organization_id: Optional[str] = None,
+    request: Optional[HttpRequest] = None,
+) -> None:
+    """
+    Track when a collaborative is deleted.
+    Since the collaborative is deleted, we need to pass its ID and title separately.
+    """
+    # For deleted objects, we can't pass the model instance directly
+    # Instead, we create a dictionary with the relevant information
+    extra_data = {
+        "collaborative_title": collaborative_title,
+        "collaborative_id": collaborative_id,
+        "action": "deleted",
+    }
+
+    # If we have the organization, we can use it as the target
+    target = None
+    if organization_id:
+        from api.models.Organization import Organization
+
+        try:
+            target = Organization.objects.get(id=organization_id)
+        except Organization.DoesNotExist:
+            pass
+
+    # Record the activity
+    from authorization.activity import record_activity
+
+    record_activity(
+        actor=user,
+        verb="deleted",
+        action_object=None,  # No action object since it's deleted
+        target=target,
+        request=request,
+        data=extra_data,
+    )
+
+
+def track_dataset_added_to_collaborative(
+    user: User,
+    collaborative: Collaborative,
+    dataset_id: str,
+    dataset_title: str,
+    request: Optional[HttpRequest] = None,
+) -> None:
+    """
+    Track when a dataset is added to a use case.
+    """
+    from api.models.Dataset import Dataset
+
+    try:
+        dataset = Dataset.objects.get(id=dataset_id)
+        track_model_activity(
+            actor=user,
+            verb="added dataset to",
+            model_instance=collaborative,
+            target=dataset,
+            request=request,
+            extra_data={
+                "collaborative_title": collaborative.title,
+                "collaborative_id": str(collaborative.id),
+                "dataset_id": dataset_id,
+                "dataset_title": dataset_title,
+            },
+        )
+    except Dataset.DoesNotExist:
+        # If the dataset doesn't exist, we still want to track the activity
+        # but we can't use the dataset as the target
+        track_model_activity(
+            actor=user,
+            verb="added dataset to",
+            model_instance=collaborative,
+            request=request,
+            extra_data={
+                "collaborative_title": collaborative.title,
+                "collaborative_id": str(collaborative.id),
+                "dataset_id": dataset_id,
+                "dataset_title": dataset_title,
+            },
+        )
+
+
+def track_dataset_removed_from_collaborative(
+    user: User,
+    collaborative: Collaborative,
+    dataset_id: str,
+    dataset_title: str,
+    request: Optional[HttpRequest] = None,
+) -> None:
+    """
+    Track when a dataset is removed from a use case.
+    """
+    from api.models.Dataset import Dataset
+
+    try:
+        dataset = Dataset.objects.get(id=dataset_id)
+        track_model_activity(
+            actor=user,
+            verb="removed dataset from",
+            model_instance=collaborative,
+            target=dataset,
+            request=request,
+            extra_data={
+                "collaborative_title": collaborative.title,
+                "collaborative_id": str(collaborative.id),
+                "dataset_id": dataset_id,
+                "dataset_title": dataset_title,
+            },
+        )
+    except Dataset.DoesNotExist:
+        # If the dataset doesn't exist, we still want to track the activity
+        # but we can't use the dataset as the target
+        track_model_activity(
+            actor=user,
+            verb="removed dataset from",
+            model_instance=collaborative,
+            request=request,
+            extra_data={
+                "collaborative_title": collaborative.title,
+                "collaborative_id": str(collaborative.id),
+                "dataset_id": dataset_id,
+                "dataset_title": dataset_title,
+            },
+        )

api/models/Collaborative.py

@@ -0,0 +1,74 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, cast
+
+from django.db import models
+from django.utils.text import slugify
+
+if TYPE_CHECKING:
+    from api.models.Dataset import Dataset
+    from api.models.Organization import Organization
+    from authorization.models import User
+
+from api.utils.enums import CollaborativeStatus, OrganizationRelationshipType
+from api.utils.file_paths import _use_case_directory_path
+
+
+class Collaborative(models.Model):
+    id = models.AutoField(primary_key=True)
+    title = models.CharField(max_length=200, unique=True, blank=True, null=True)
+    summary = models.CharField(max_length=10000, blank=True, null=True)
+    logo = models.ImageField(
+        upload_to=_use_case_directory_path, max_length=300, blank=True, null=True
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
+    website = models.URLField(blank=True)
+    contact_email = models.EmailField(blank=True, null=True)
+    slug = models.SlugField(max_length=75, null=True, blank=True, unique=True)
+    user = models.ForeignKey("authorization.User", on_delete=models.CASCADE)
+    organization = models.ForeignKey(
+        "api.Organization", on_delete=models.CASCADE, null=True, blank=True
+    )
+    status = models.CharField(
+        max_length=50,
+        default=CollaborativeStatus.DRAFT,
+        choices=CollaborativeStatus.choices,
+    )
+    datasets = models.ManyToManyField("api.Dataset", blank=True)
+    tags = models.ManyToManyField("api.Tag", blank=True)
+    sectors = models.ManyToManyField(
+        "api.Sector", blank=True, related_name="collaboratives"
+    )
+    contributors = models.ManyToManyField(
+        "authorization.User", blank=True, related_name="contributed_collaboratives"
+    )
+    # Organizations can be added as supporters or partners through the intermediate model
+    organizations = models.ManyToManyField(
+        "api.Organization",
+        through="api.CollaborativeOrganizationRelationship",
+        related_name="related_collaboratives",
+        blank=True,
+    )
+    started_on = models.DateField(blank=True, null=True)
+    completed_on = models.DateField(blank=True, null=True)
+    platform_url = models.URLField(blank=True, null=True)
+
+    def save(self, *args: Any, **kwargs: Any) -> None:
+        if self.title and not self.slug:
+            self.slug = slugify(cast(str, self.title))
+        super().save(*args, **kwargs)
+
+    @property
+    def is_individual_collaborative(self):
+        return self.organization is None
+
+    @property
+    def sectors_indexing(self):
+        return [sector.name for sector in self.sectors.all()]  # type: ignore
+
+    @property
+    def tags_indexing(self):
+        return [tag.value for tag in self.tags.all()]  # type: ignore
+
+    class Meta:
+        db_table = "collaborative"

api/models/CollaborativeMetadata.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+from api.models.Metadata import BaseMetadata
+
+if TYPE_CHECKING:
+    from api.models.Collaborative import Collaborative
+
+
+class CollaborativeMetadata(BaseMetadata):
+    collaborative = models.ForeignKey(
+        "api.Collaborative",
+        on_delete=models.CASCADE,
+        null=False,
+        blank=False,
+        related_name="metadata",
+    )
+
+    def __str__(self) -> str:
+        return f"{self.collaborative.title} - {self.metadata_item.label}"
+
+    class Meta(BaseMetadata.Meta):
+        db_table = "collaborative_metadata"
+        unique_together = ("collaborative", "metadata_item")

api/models/CollaborativeOrganizationRelationship.py

@@ -0,0 +1,29 @@
+"""Model for relationship between collaborative and organizations."""
+
+from django.db import models
+
+from api.utils.enums import OrganizationRelationshipType
+
+
+class CollaborativeOrganizationRelationship(models.Model):
+    """Intermediate model for Collaborative-Organization relationship.
+    This model stores the type of relationship between a collaborative and an organization.
+    """
+
+    collaborative = models.ForeignKey("api.Collaborative", on_delete=models.CASCADE)
+    organization = models.ForeignKey("api.Organization", on_delete=models.CASCADE)
+    relationship_type = models.CharField(
+        max_length=50,
+        choices=OrganizationRelationshipType.choices,
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        db_table = "collaborative_organization_relationship"
+        unique_together = ("collaborative", "organization", "relationship_type")
+        verbose_name = "Collaborative Organization Relationship"
+        verbose_name_plural = "Collaborative Organization Relationships"
+
+    def __str__(self) -> str:
+        return f"{self.collaborative.title} - {self.organization.name} ({self.relationship_type})"

api/models/__init__.py

@@ -1,5 +1,10 @@
 from api.models.AccessModel import AccessModel, AccessModelResource
 from api.models.Catalog import Catalog
+from api.models.Collaborative import Collaborative
+from api.models.CollaborativeMetadata import CollaborativeMetadata
+from api.models.CollaborativeOrganizationRelationship import (
+    CollaborativeOrganizationRelationship,
+)
 from api.models.Dataset import Dataset, Tag
 from api.models.DatasetMetadata import DatasetMetadata
 from api.models.DataSpace import DataSpace