feat: Add metadata fields to core entities (API) (#3315)

api/conftest.py

@@ -659,23 +659,23 @@ def task_processor_synchronously(settings):
 
 
 @pytest.fixture()
-def a_metadata_field(organisation):
+def a_metadata_field(organisation: Organisation) -> MetadataField:
     return MetadataField.objects.create(name="a", type="int", organisation=organisation)
 
 
 @pytest.fixture()
-def b_metadata_field(organisation):
+def b_metadata_field(organisation: Organisation) -> MetadataField:
     return MetadataField.objects.create(name="b", type="str", organisation=organisation)
 
 
 @pytest.fixture()
 def required_a_environment_metadata_field(
-    organisation,
-    a_metadata_field,
-    environment,
-    project,
-    project_content_type,
-):
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    environment: Environment,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
     environment_type = ContentType.objects.get_for_model(environment)
     model_field = MetadataModelField.objects.create(
         field=a_metadata_field,
@@ -689,7 +689,119 @@ def required_a_environment_metadata_field(
 
 
 @pytest.fixture()
-def optional_b_environment_metadata_field(organisation, b_metadata_field, environment):
+def required_a_feature_metadata_field(
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    feature_content_type: ContentType,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=feature_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=project_content_type, object_id=project.id, model_field=model_field
+    )
+
+    return model_field
+
+
+@pytest.fixture()
+def required_a_feature_metadata_field_using_organisation_content_type(
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    feature_content_type: ContentType,
+    project: Project,
+    organisation_content_type: ContentType,
+) -> MetadataModelField:
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=feature_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=organisation_content_type,
+        object_id=organisation.id,
+        model_field=model_field,
+    )
+
+    return model_field
+
+
+@pytest.fixture()
+def required_a_segment_metadata_field(
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    segment_content_type: ContentType,
+    project: Project,
+    project_content_type: ContentType,
+) -> MetadataModelField:
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=segment_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=project_content_type, object_id=project.id, model_field=model_field
+    )
+
+    return model_field
+
+
+@pytest.fixture()
+def required_a_segment_metadata_field_using_organisation_content_type(
+    organisation: Organisation,
+    a_metadata_field: MetadataField,
+    segment_content_type: ContentType,
+    project: Project,
+    organisation_content_type: ContentType,
+) -> MetadataModelField:
+    model_field = MetadataModelField.objects.create(
+        field=a_metadata_field,
+        content_type=segment_content_type,
+    )
+
+    MetadataModelFieldRequirement.objects.create(
+        content_type=organisation_content_type,
+        object_id=organisation.id,
+        model_field=model_field,
+    )
+
+    return model_field
+
+
+@pytest.fixture()
+def optional_b_feature_metadata_field(
+    organisation: Organisation, b_metadata_field: MetadataField, feature: Feature
+) -> MetadataModelField:
+    feature_type = ContentType.objects.get_for_model(feature)
+
+    return MetadataModelField.objects.create(
+        field=b_metadata_field,
+        content_type=feature_type,
+    )
+
+
+@pytest.fixture()
+def optional_b_segment_metadata_field(
+    organisation: Organisation, b_metadata_field: MetadataField, segment: Segment
+) -> MetadataModelField:
+    segment_type = ContentType.objects.get_for_model(segment)
+
+    return MetadataModelField.objects.create(
+        field=b_metadata_field,
+        content_type=segment_type,
+    )
+
+
+@pytest.fixture()
+def optional_b_environment_metadata_field(
+    organisation: Organisation,
+    b_metadata_field: MetadataField,
+    environment: Environment,
+) -> MetadataModelField:
     environment_type = ContentType.objects.get_for_model(environment)
 
     return MetadataModelField.objects.create(
@@ -699,7 +811,10 @@ def optional_b_environment_metadata_field(organisation, b_metadata_field, enviro
 
 
 @pytest.fixture()
-def environment_metadata_a(environment, required_a_environment_metadata_field):
+def environment_metadata_a(
+    environment: Environment,
+    required_a_environment_metadata_field: MetadataModelField,
+) -> Metadata:
     environment_type = ContentType.objects.get_for_model(environment)
     return Metadata.objects.create(
         object_id=environment.id,
@@ -710,7 +825,10 @@ def environment_metadata_a(environment, required_a_environment_metadata_field):
 
 
 @pytest.fixture()
-def environment_metadata_b(environment, optional_b_environment_metadata_field):
+def environment_metadata_b(
+    environment: Environment,
+    optional_b_environment_metadata_field: MetadataModelField,
+) -> Metadata:
     environment_type = ContentType.objects.get_for_model(environment)
     return Metadata.objects.create(
         object_id=environment.id,
@@ -721,15 +839,30 @@ def environment_metadata_b(environment, optional_b_environment_metadata_field):
 
 
 @pytest.fixture()
-def environment_content_type():
+def environment_content_type() -> ContentType:
     return ContentType.objects.get_for_model(Environment)
 
 
 @pytest.fixture()
-def project_content_type():
+def feature_content_type() -> ContentType:
+    return ContentType.objects.get_for_model(Feature)
+
+
+@pytest.fixture()
+def segment_content_type() -> ContentType:
+    return ContentType.objects.get_for_model(Segment)
+
+
+@pytest.fixture()
+def project_content_type() -> ContentType:
     return ContentType.objects.get_for_model(Project)
 
 
+@pytest.fixture()
+def organisation_content_type() -> ContentType:
+    return ContentType.objects.get_for_model(Organisation)
+
+
 @pytest.fixture
 def manage_user_group_permission(db):
     return OrganisationPermissionModel.objects.get(key=MANAGE_USER_GROUPS)

api/features/models.py

@@ -12,6 +12,7 @@
     SoftDeleteExportableModel,
     abstract_base_auditable_model_factory,
 )
+from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import (
     NON_FIELD_ERRORS,
     ObjectDoesNotExist,
@@ -75,6 +76,7 @@
 )
 from features.versioning.models import EnvironmentFeatureVersion
 from integrations.github.models import GithubConfiguration
+from metadata.models import Metadata
 from projects.models import Project
 from projects.tags.models import Tag
 
@@ -129,6 +131,8 @@ class Feature(
 
     objects = FeatureManager()
 
+    metadata = GenericRelation(Metadata)
+
     class Meta:
         # Note: uniqueness index is added in explicit SQL in the migrations (See 0005, 0050)
         # TODO: after upgrade to Django 4.0 use UniqueConstraint()

api/features/serializers.py

@@ -12,6 +12,7 @@
 from environments.sdk.serializers_mixins import (
     HideSensitiveFieldsSerializerMixin,
 )
+from metadata.serializers import MetadataSerializer, SerializerWithMetadata
 from projects.models import Project
 from users.serializers import (
     UserIdsSerializer,
@@ -296,17 +297,44 @@ def get_last_modified_in_current_environment(
         return getattr(instance, "last_modified_in_current_environment", None)
 
 
-class ListFeatureSerializer(CreateFeatureSerializer):
+class FeatureSerializerWithMetadata(SerializerWithMetadata, CreateFeatureSerializer):
+    metadata = MetadataSerializer(required=False, many=True)
+
+    class Meta(CreateFeatureSerializer.Meta):
+        fields = CreateFeatureSerializer.Meta.fields + ("metadata",)
+
+    def get_project(self, validated_data: dict = None) -> Project:
+        project = self.context.get("project")
+        if project:
+            return project
+        else:
+            raise serializers.ValidationError(
+                "Unable to retrieve project for metadata validation."
+            )
+
+
+class UpdateFeatureSerializerWithMetadata(FeatureSerializerWithMetadata):
+    """prevent users from changing certain values after creation"""
+
+    class Meta(FeatureSerializerWithMetadata.Meta):
+        read_only_fields = FeatureSerializerWithMetadata.Meta.read_only_fields + (
+            "default_enabled",
+            "initial_value",
+            "name",
+        )
+
+
+class ListFeatureSerializer(FeatureSerializerWithMetadata):
     # This exists purely to reduce the conflicts for the EE repository
     # which has some extra behaviour here to support Oracle DB.
     pass
 
 
-class UpdateFeatureSerializer(CreateFeatureSerializer):
+class UpdateFeatureSerializer(ListFeatureSerializer):
     """prevent users from changing certain values after creation"""
 
-    class Meta(CreateFeatureSerializer.Meta):
-        read_only_fields = CreateFeatureSerializer.Meta.read_only_fields + (
+    class Meta(ListFeatureSerializer.Meta):
+        read_only_fields = ListFeatureSerializer.Meta.read_only_fields + (
             "default_enabled",
             "initial_value",
             "name",

api/features/views.py

@@ -107,8 +107,8 @@ class FeatureViewSet(viewsets.ModelViewSet):
     def get_serializer_class(self):
         return {
             "list": ListFeatureSerializer,
-            "retrieve": CreateFeatureSerializer,
-            "create": CreateFeatureSerializer,
+            "retrieve": ListFeatureSerializer,
+            "create": ListFeatureSerializer,
             "update": UpdateFeatureSerializer,
             "partial_update": UpdateFeatureSerializer,
         }.get(self.action, ProjectFeatureSerializer)
@@ -131,7 +131,9 @@ def get_queryset(self):
                     ),
                 ),
             )
-            .prefetch_related("multivariate_options", "owners", "tags", "group_owners")
+            .prefetch_related(
+                "multivariate_options", "owners", "tags", "group_owners", "metadata"
+            )
         )
 
         query_serializer = FeatureQuerySerializer(data=self.request.query_params)

api/metadata/models.py

@@ -6,22 +6,16 @@
 from django.db import models
 
 from organisations.models import Organisation
-from projects.models import Project
 
 from .fields import GenericObjectID
 
 FIELD_VALUE_MAX_LENGTH = 2000
 
-METADATA_SUPPORTED_MODELS = ["environment"]
-
 # A map of model name to a function that takes the object id and returns the organisation_id
 SUPPORTED_REQUIREMENTS_MAPPING = {
-    "environment": {
-        "organisation": lambda org_id: org_id,
-        "project": lambda project_id: Project.objects.get(
-            id=project_id
-        ).organisation_id,
-    }
+    "environment": ["organisation", "project"],
+    "feature": ["organisation", "project"],
+    "segment": ["organisation", "project"],
 }
 
 

api/metadata/serializers.py

@@ -9,7 +9,6 @@
 )
 
 from .models import (
-    SUPPORTED_REQUIREMENTS_MAPPING,
     Metadata,
     MetadataField,
     MetadataModelField,
@@ -55,21 +54,13 @@ class Meta:
     def validate(self, data):
         data = super().validate(data)
         for requirement in data.get("is_required_for", []):
-            try:
-                get_org_id_func = SUPPORTED_REQUIREMENTS_MAPPING[
-                    data["content_type"].model
-                ][requirement["content_type"].model]
-            except KeyError:
-                raise serializers.ValidationError(
-                    "Invalid requirement for model {}".format(
-                        data["content_type"].model
-                    )
-                )
-
-            if (
-                get_org_id_func(requirement["object_id"])
-                != data["field"].organisation_id
-            ):
+            org_id = (
+                requirement["content_type"]
+                .model_class()
+                .objects.get(id=requirement["object_id"])
+                .organisation_id
+            )
+            if org_id != data["field"].organisation_id:
                 raise serializers.ValidationError(
                     "The requirement organisation does not match the field organisation"
                 )