feat(versioning): add logic to create version in single endpoint

api/features/versioning/serializers.py

@@ -40,6 +40,127 @@ class Meta:
         )
 
 
+class EnvironmentFeatureVersionCreateSerializer(EnvironmentFeatureVersionSerializer):
+    feature_states_to_create = EnvironmentFeatureVersionFeatureStateSerializer(
+        many=True, allow_null=True, required=False
+    )
+    feature_states_to_update = EnvironmentFeatureVersionFeatureStateSerializer(
+        many=True, allow_null=True, required=False
+    )
+    segment_ids_to_delete_overrides = serializers.ListSerializer(
+        child=serializers.IntegerField(),
+        required=False,
+        allow_null=True,
+    )
+    publish = serializers.BooleanField(required=False, default=False)
+
+    class Meta(EnvironmentFeatureVersionSerializer.Meta):
+        fields = EnvironmentFeatureVersionSerializer.Meta.fields + (
+            "feature_states_to_create",
+            "feature_states_to_update",
+            "segment_ids_to_delete_overrides",
+            "publish",
+        )
+        non_model_fields = (
+            "feature_states_to_create",
+            "feature_states_to_update",
+            "segment_ids_to_delete_overrides",
+            "publish",
+        )
+
+    def create(self, validated_data):
+        for field_name in self.Meta.non_model_fields:
+            validated_data.pop(field_name, None)
+
+        version = super().create(validated_data)
+
+        for feature_state_to_create in self.initial_data.get(
+            "feature_states_to_create", []
+        ):
+            self._create_feature_state(
+                {**feature_state_to_create, "environment": version.environment_id},
+                version,
+            )
+
+        for feature_state_to_update in self.initial_data.get(
+            "feature_states_to_update", []
+        ):
+            self._update_feature_state(feature_state_to_update, version)
+
+        self._delete_feature_states(
+            self.initial_data.get("segment_ids_to_delete_overrides", []), version
+        )
+
+        if self.initial_data.get("publish", False):
+            request = self.context["request"]
+            version.publish(
+                published_by=(
+                    request.user if isinstance(request.user, FFAdminUser) else None
+                )
+            )
+
+        return version
+
+    def _create_feature_state(
+        self, feature_state: dict, version: EnvironmentFeatureVersion
+    ) -> None:
+        if not self._is_segment_override(feature_state):
+            raise serializers.ValidationError(
+                "Cannot create FeatureState objects that are not segment overrides."
+            )
+
+        segment_id = feature_state["feature_segment"]["segment"]
+        if version.feature_states.filter(
+            feature_segment__segment_id=segment_id
+        ).exists():
+            raise serializers.ValidationError(
+                "Segment override already exists for Segment %d", segment_id
+            )
+
+        fs_serializer = EnvironmentFeatureVersionFeatureStateSerializer(
+            data=feature_state,
+            context={
+                "feature": version.feature,
+                "environment": version.environment,
+                "environment_feature_version": version,
+            },
+        )
+        fs_serializer.is_valid(raise_exception=True)
+        fs_serializer.save(
+            environment_feature_version=version,
+            environment=version.environment,
+            feature=version.feature,
+        )
+
+    def _update_feature_state(
+        self, feature_state: dict, version: EnvironmentFeatureVersion
+    ) -> None:
+        if self._is_segment_override(feature_state):
+            instance = version.feature_states.get(
+                feature_segment__segment_id=feature_state["feature_segment"]["segment"]
+            )
+        else:
+            instance = version.feature_states.get(feature_segment__isnull=True)
+
+        fs_serializer = EnvironmentFeatureVersionFeatureStateSerializer(
+            instance=instance, data=feature_state
+        )
+        fs_serializer.is_valid(raise_exception=True)
+        fs_serializer.save(
+            environment_feature_version=version, environment=version.environment
+        )
+
+    def _delete_feature_states(
+        self, segment_ids: list[int], version: EnvironmentFeatureVersion
+    ) -> None:
+        version.feature_states.filter(
+            feature_segment__segment_id__in=segment_ids
+        ).delete()
+
+    def _is_segment_override(self, feature_state: dict) -> bool:
+        return feature_state.get("feature_segment") is not None
+
+
 class EnvironmentFeatureVersionPublishSerializer(serializers.Serializer):
     live_from = serializers.DateTimeField(required=False)
 

api/features/versioning/views.py

@@ -27,6 +27,7 @@
     EnvironmentFeatureVersionPermissions,
 )
 from features.versioning.serializers import (
+    EnvironmentFeatureVersionCreateSerializer,
     EnvironmentFeatureVersionFeatureStateSerializer,
     EnvironmentFeatureVersionPublishSerializer,
     EnvironmentFeatureVersionQuerySerializer,
@@ -48,7 +49,6 @@ class EnvironmentFeatureVersionViewSet(
     CreateModelMixin,
     DestroyModelMixin,
 ):
-    serializer_class = EnvironmentFeatureVersionSerializer
     permission_classes = [IsAuthenticated, EnvironmentFeatureVersionPermissions]
 
     def __init__(self, *args, **kwargs):
@@ -62,6 +62,8 @@ def get_serializer_class(self):
         match self.action:
             case "publish":
                 return EnvironmentFeatureVersionPublishSerializer
+            case "create":
+                return EnvironmentFeatureVersionCreateSerializer
             case _:
                 return EnvironmentFeatureVersionSerializer
 

api/tests/unit/features/versioning/test_unit_versioning_views.py

@@ -638,3 +638,75 @@ def test_disable_v2_versioning_returns_bad_request_if_not_using_v2_versioning(
 
     # Then
     assert response.status_code == status.HTTP_400_BAD_REQUEST
+
+
+def test_create_new_version_with_changes_in_single_request(
+    feature: Feature,
+    segment: Segment,
+    segment_featurestate: FeatureState,
+    admin_client_new: APIClient,
+    environment_v2_versioning: Environment,
+) -> None:
+    # Given
+    another_segment = Segment.objects.create(
+        name="another-segment", project=feature.project
+    )
+
+    url = reverse(
+        "api-v1:versioning:environment-feature-versions-list",
+        args=[environment_v2_versioning.id, feature.id],
+    )
+
+    data = {
+        "publish": True,
+        "feature_states_to_update": [
+            {
+                "feature_segment": None,
+                "enabled": True,
+                "feature_state_value": {"type": "unicode", "string_value": "updated!"},
+            }
+        ],
+        "feature_states_to_create": [
+            {
+                "feature_segment": {
+                    # TODO: priorities?
+                    "segment": another_segment.id,
+                },
+                "enabled": True,
+                "feature_state_value": {"type": "unicode", "string_value": "foo"},
+            }
+        ],
+        "segment_ids_to_delete_overrides": [segment.id],
+    }
+
+    # When
+    response = admin_client_new.post(
+        url, data=json.dumps(data), content_type="application/json"
+    )
+
+    # Then
+    assert response.status_code == status.HTTP_201_CREATED
+
+    new_version_uuid = response.json()["uuid"]
+    new_version = EnvironmentFeatureVersion.objects.get(uuid=new_version_uuid)
+
+    assert new_version.feature_states.count() == 2
+
+    new_version_environment_fs = new_version.feature_states.filter(
+        feature_segment__isnull=True
+    ).get()
+    assert new_version_environment_fs.get_feature_state_value() == "updated!"
+    assert new_version_environment_fs.enabled is True
+
+    new_version_segment_fs = new_version.feature_states.filter(
+        feature_segment__segment=another_segment
+    ).get()
+    assert new_version_segment_fs.get_feature_state_value() == "foo"
+    assert new_version_segment_fs.enabled is True
+
+    assert not new_version.feature_states.filter(
+        feature_segment__segment=segment
+    ).exists()
+
+    assert new_version.published is True
+    assert new_version.is_live is True