Remove anonymous. Add generic evaluation endpoint

augustuswm · augustuswm · commit 3ae32acda6c2 · 2021-03-20T20:08:29.000-05:00
diff --git a/src/api/urls/v1.py b/src/api/urls/v1.py
@@ -6,7 +6,8 @@
 from rest_framework import authentication, permissions, routers
 
 from environments.identities.traits.views import SDKTraits
-from environments.identities.views import SDKIdentities, SDKAnonymousIdentities
+from environments.identities.views import SDKIdentities
+from evaluations.views import SDKEvaluations
 from features.views import SDKFeatureStates
 from organisations.views import chargebee_webhook
 
@@ -42,8 +43,7 @@
     # Client SDK urls
     url(r"^flags/$", SDKFeatureStates.as_view(), name="flags"),
     url(r"^identities/$", SDKIdentities.as_view(), name="sdk-identities"),
-    url(r"^identities/anonymous$", SDKAnonymousIdentities.as_view(),
-        name="sdk-anonymous-identities"),
+    url(r"^evaluate/$", SDKEvaluations.as_view(), name="evaluations"),
     url(r"^traits/", include(traits_router.urls), name="traits"),
     url(r"^analytics/flags/$", SDKAnalyticsFlags.as_view()),
     # API documentation
diff --git a/src/environments/identities/models.py b/src/environments/identities/models.py
@@ -8,7 +8,6 @@
 from environments.identities.traits.models import Trait
 from features.models import FeatureState
 
-
 @python_2_unicode_compatible
 class Identity(models.Model):
     identifier = models.CharField(max_length=2000)
@@ -25,6 +24,73 @@ class Meta:
         # issues with production deployment due to multi server configuration.
         db_table = "environments_identity"
 
+    def get_feature_states(self, features: typing.List[str], traits: typing.List[Trait] = None):
+        """
+        Get a specified set of feature states for an identity. This method returns a single flag for
+        each feature in the requested list that exists in the identity's environment's project. The 
+        flag returned is the correct flag based on the priorities as follows (highest -> lowest):
+
+            1. Identity - flag override for this specific identity
+            2. Segment - flag overridden for a segment this identity belongs to
+            3. Environment - default value for the environment
+
+        :return: (list) flags for an identity with the correct values based on
+            identity / segment priorities
+        """
+        segments = self.get_segments(traits=traits)
+
+        # define sub queries
+        belongs_to_environment_query = Q(environment=self.environment)
+        is_requested = Q(feature__name__in=features)
+        overridden_for_identity_query = Q(identity=self)
+        overridden_for_segment_query = Q(
+            feature_segment__segment__in=segments,
+            feature_segment__environment=self.environment,
+        )
+        environment_default_query = Q(identity=None, feature_segment=None)
+
+        # Only look for identity overrides if this identity has been persisted already
+        if self._state.adding:
+            full_query = belongs_to_environment_query & is_requested & (
+                overridden_for_segment_query
+                | environment_default_query
+            )
+        else:
+            full_query = belongs_to_environment_query & is_requested & (
+                overridden_for_identity_query
+                | overridden_for_segment_query
+                | environment_default_query
+            )
+
+        select_related_args = [
+            "feature",
+            "feature_state_value",
+            "feature_segment",
+            "feature_segment__segment",
+        ]
+
+        # When Project's hide_disabled_flags enabled, exclude disabled Features from the list
+        all_flags = FeatureState.objects.select_related(*select_related_args).filter(
+            full_query
+        )
+
+        # iterate over all the flags and build a dictionary keyed on feature with the highest priority flag
+        # for the given identity as the value.
+        identity_flags = {}
+        for flag in all_flags:
+            if flag.feature_id not in identity_flags:
+                identity_flags[flag.feature_id] = flag
+            else:
+                if flag > identity_flags[flag.feature_id]:
+                    identity_flags[flag.feature_id] = flag
+
+        if self.environment.project.hide_disabled_flags:
+            # filter out any flags that are disabled if configured on the project
+            # Note: done here instead of the DB because of CH1245
+            return [value for value in identity_flags.values() if value.enabled]
+
+        return list(identity_flags.values())
+
     def get_all_feature_states(self, traits: typing.List[Trait] = None):
         """
         Get all feature states for an identity. This method returns a single flag for
diff --git a/src/environments/identities/views.py b/src/environments/identities/views.py
@@ -198,113 +198,4 @@ def _get_all_feature_states_for_user_response(self, identity, trait_models=None)
         response = {"flags": serialized_flags.data,
                     "traits": serialized_traits.data}
 
-        return Response(data=response, status=status.HTTP_200_OK)
-
-
-class SDKAnonymousIdentities(SDKAPIView):
-    serializer_class = IdentifyWithTraitsSerializer
-    pagination_class = None  # set here to ensure documentation is correct
-
-    def get(self, request):
-        identifier = request.query_params.get("identifier")
-        if not identifier:
-            return Response(
-                {"detail": "Missing identifier"}
-            )  # TODO: add 400 status - will this break the clients?
-
-        try:
-            identity = (
-                Identity.objects.select_related(
-                    "environment", "environment__project")
-                .prefetch_related("identity_traits", "environment__project__segments")
-                .get(identifier=identifier, environment=request.environment)
-            )
-        except ObjectDoesNotExist:
-            identity = Identity(identifier=identifier,
-                                environment=request.environment)
-
-        # Create temporary trait models
-        temporary_traits = request.query_params.get("traits")
-
-        if temporary_traits:
-            decoded_traits = json.loads(temporary_traits)
-            traits = list(map(lambda t: self._make_temporary_trait(
-                identity, t), decoded_traits))
-        else:
-            traits = None
-
-        feature_name = request.query_params.get("feature")
-        if feature_name:
-            return self._get_single_feature_state_response(identity, feature_name)
-        else:
-            return self._get_all_feature_states_for_user_response(identity, traits)
-
-    def _make_temporary_trait(self, identity, trait_data):
-        print(trait_data)
-        return Trait(
-            identity=identity,
-            trait_key=trait_data.get('trait_key'),
-            value_type=trait_data.get('value_type'),
-            boolean_value=trait_data.get('boolean_value'),
-            integer_value=trait_data.get('integer_value'),
-            string_value=trait_data.get('string_value'),
-            float_value=trait_data.get('float_value')
-        )
-
-    def get_serializer_context(self):
-        context = super(SDKIdentities, self).get_serializer_context()
-        if hasattr(self.request, "environment"):
-            # only set it if the request has the attribute to ensure that the
-            # documentation works correctly still
-            context["environment"] = self.request.environment
-        return context
-
-    def post(self, request):
-        serializer = self.get_serializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-        instance = serializer.save()
-
-        # we need to serialize the response again to ensure that the
-        # trait values are serialized correctly
-        response_serializer = IdentifyWithTraitsSerializer(instance=instance)
-        return Response(response_serializer.data)
-
-    def _get_single_feature_state_response(self, identity, feature_name):
-        for feature_state in identity.get_all_feature_states():
-            if feature_state.feature.name == feature_name:
-                serializer = FeatureStateSerializerFull(feature_state)
-                return Response(data=serializer.data, status=status.HTTP_200_OK)
-
-        return Response(
-            {"detail": "Given feature not found"}, status=status.HTTP_404_NOT_FOUND
-        )
-
-    def _get_all_feature_states_for_user_response(self, identity, trait_models=None):
-        """
-        Get all feature states for an identity
-
-        :param identity: Identity model to return feature states for
-        :param trait_models: optional list of trait_models to pass in for organisations that don't persist them
-        :return: Response containing lists of both serialized flags and traits
-        """
-        shadowed_keys = [] if trait_models is None else map(
-            lambda t: t.trait_key, trait_models)
-
-        traits = identity.identity_traits.all() if trait_models is None else list(
-            identity.identity_traits.all().exclude(trait_key__in=shadowed_keys)) + trait_models
-
-        all_feature_states = identity.get_all_feature_states(traits)
-
-        serialized_flags = FeatureStateSerializerFull(
-            all_feature_states, many=True)
-
-        serialized_traits = TraitSerializerBasic(
-            traits, many=True
-        )
-
-        identify_integrations(identity, all_feature_states)
-
-        response = {"flags": serialized_flags.data,
-                    "traits": serialized_traits.data}
-
-        return Response(data=response, status=status.HTTP_200_OK)
+        return Response(data=response, status=status.HTTP_200_OK)
diff --git a/src/evaluations/serializers.py b/src/evaluations/serializers.py
diff --git a/src/evaluations/views.py b/src/evaluations/views.py
@@ -0,0 +1,122 @@
+from collections import namedtuple
+import json
+
+from django.core.exceptions import ObjectDoesNotExist
+
+import coreapi
+from rest_framework import status, viewsets
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.schemas import AutoSchema
+
+from app.pagination import CustomPagination
+from environments.identities.helpers import identify_integrations
+from environments.identities.models import Identity
+from environments.identities.serializers import IdentitySerializer
+from environments.identities.traits.models import Trait
+from environments.identities.traits.serializers import TraitSerializerBasic
+from environments.models import Environment
+from environments.permissions.permissions import NestedEnvironmentPermissions
+from environments.sdk.serializers import (
+    IdentifyWithTraitsSerializer,
+    IdentitySerializerWithTraitsAndSegments,
+)
+from features.serializers import FeatureStateSerializerFull
+from util.views import SDKAPIView
+
+class SDKEvaluations(SDKAPIView):
+    pagination_class = None
+
+    def get(self, request):
+        identifier = request.query_params.get("identifier")
+
+        if identifier is None:
+            return Response(
+                {"detail": "Missing identifier"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        try:
+            identity = (
+                Identity.objects.select_related(
+                    "environment", "environment__project")
+                .prefetch_related("identity_traits", "environment__project__segments")
+                .get(identifier=identifier, environment=request.environment)
+            )
+        except ObjectDoesNotExist:
+            identity = Identity(identifier=identifier,
+                                environment=request.environment)
+
+        # Create temporary trait models
+        temporary_traits = request.query_params.get("traits")
+
+        try:
+            if temporary_traits:
+                decoded_traits = json.loads(temporary_traits)
+                traits = list(map(lambda t: self._make_temporary_trait(
+                    identity, t), decoded_traits))
+            else:
+                traits = None
+        except json.JSONDecodeError:
+            return Response(
+                {"detail": "Unable to parse traits"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        features = request.query_params.get("features")
+
+        try:
+            if features:
+                features_list = json.loads(features)
+            else:
+                features_list = None
+        except json.JSONDecodeError:
+            return Response(
+                {"detail": "Unable to parse features list"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        return self._get_feature_states_for_user_response(identity, traits, features_list)
+
+    def _get_feature_states_for_user_response(self, identity, trait_models=None, features=None):
+        """
+        Get all feature (or a subset of them) states for an identity
+
+        :param identity: Identity model to return feature states for
+        :param trait_models: optional list of trait_models to apply over top of any already persisted traits for the identity
+        :return: Response containing lists of both serialized flags and traits
+        """
+        shadowed_keys = [] if trait_models is None else map(
+            lambda t: t.trait_key, trait_models)
+
+        traits = identity.identity_traits.all() if trait_models is None else list(
+            identity.identity_traits.all().exclude(trait_key__in=shadowed_keys)) + trait_models
+
+        if features is None:
+            feature_states = identity.get_all_feature_states(traits)
+        else:
+            feature_states = identity.get_feature_states(features, traits)
+
+        serialized_flags = FeatureStateSerializerFull(
+            feature_states, many=True)
+
+        serialized_traits = TraitSerializerBasic(
+            traits, many=True
+        )
+
+        identify_integrations(identity, feature_states)
+
+        response = {"flags": serialized_flags.data,
+                    "traits": serialized_traits.data}
+
+        return Response(data=response, status=status.HTTP_200_OK)
+
+
+    def _make_temporary_trait(self, identity, trait_data):
+        print(trait_data)
+        return Trait(
+            identity=identity,
+            trait_key=trait_data.get('trait_key'),
+            value_type=trait_data.get('value_type'),
+            boolean_value=trait_data.get('boolean_value'),
+            integer_value=trait_data.get('integer_value'),
+            string_value=trait_data.get('string_value'),
+            float_value=trait_data.get('float_value')
+        )
diff --git a/src/features/models.py b/src/features/models.py
@@ -412,10 +412,12 @@ def generate_feature_state_value_data(self, value):
 
     def __str__(self):
         if self.environment is not None:
-            return "Project %s - Environment %s - Feature %s - Enabled: %r" % (
+            return "Project %s - Environment %s - Feature %s - Segment %s - Identity %s - Enabled: %r" % (
                 self.environment.project.name,
                 self.environment.name,
                 self.feature.name,
+                self.feature_segment,
+                self.identity,
                 self.enabled,
             )
         elif self.identity is not None:
