class IdentitySerializerFull(serializers.ModelSerializer): identity_features = FeatureStateSerializerFull(many=True) environment = EnvironmentSerializerFull() class Meta: model = Identity fields = ("id", "identifier", "identity_features", "environment")
class IdentitySerializerFull(serializers.ModelSerializer): identity_features = FeatureStateSerializerFull(many=True) environment = EnvironmentSerializerFull() class Meta: model = Identity fields = ('id', 'identifier', 'identity_features', 'environment')
class EnvironmentSerializerFull(serializers.ModelSerializer): feature_states = FeatureStateSerializerFull(many=True) project = ProjectSerializer() class Meta: model = Environment fields = ('id', 'name', 'feature_states', 'project', 'api_key')
class EnvironmentSerializerFull(serializers.ModelSerializer): feature_states = FeatureStateSerializerFull(many=True) project = ProjectSerializer() class Meta: model = Environment fields = ("id", "name", "feature_states", "project", "api_key")
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 """ all_feature_states = identity.get_all_feature_states() serialized_flags = FeatureStateSerializerFull(all_feature_states, many=True) serialized_traits = TraitSerializerBasic( identity.identity_traits.all(), many=True) # If we have an amplitude configured, send the flags viewed by the user to their API if (hasattr(identity.environment, "amplitude_config") and identity.environment.amplitude_config.api_key): amplitude = AmplitudeWrapper( identity.environment.amplitude_config.api_key) user_data = amplitude.generate_user_data( user_id=identity.identifier, feature_states=all_feature_states) amplitude.identify_user_async(user_data=user_data) response = { "flags": serialized_flags.data, "traits": serialized_traits.data } return Response(data=response, status=status.HTTP_200_OK)
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)
class IdentitySerializerWithTraitsAndSegments(serializers.Serializer): def update(self, instance, validated_data): pass def create(self, validated_data): pass flags = FeatureStateSerializerFull(many=True) traits = TraitSerializerBasic(many=True) segments = SegmentSerializerBasic(many=True)
def _get_all_feature_states_for_user_response(self, identity): serialized_flags = FeatureStateSerializerFull( identity.get_all_feature_states(), many=True) serialized_traits = TraitSerializerBasic( identity.get_all_user_traits(), many=True) response = { "flags": serialized_flags.data, "traits": serialized_traits.data } return Response(data=response, status=status.HTTP_200_OK)
class IdentifyWithTraitsSerializer(serializers.Serializer): identifier = serializers.CharField(write_only=True, required=True) traits = TraitSerializerBasic(required=False, many=True) flags = FeatureStateSerializerFull(read_only=True, many=True) def create(self, validated_data): """ Create the identity with the associated traits (optionally store traits if flag set on org) """ environment = self.context["environment"] identity, created = Identity.objects.get_or_create( identifier=validated_data["identifier"], environment=environment) if not created and environment.project.organisation.persist_trait_data: # if this is an update and we're persisting traits, then we need to # partially update any traits and return the full list return self.update(instance=identity, validated_data=validated_data) # generate traits for the identity and store them if configured to do so trait_models = identity.generate_traits( validated_data.get("traits", []), persist=environment.project.organisation.persist_trait_data, ) return { "identity": identity, "traits": trait_models, "flags": identity.get_all_feature_states(traits=trait_models), } def update(self, instance, validated_data): """ partially update any traits and return the full list of traits and flags """ trait_data_items = validated_data.get("traits", []) updated_traits = instance.update_traits(trait_data_items) return { "identity": instance, "traits": updated_traits, "flags": instance.get_all_feature_states(traits=updated_traits), }
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 _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 """ all_feature_states = identity.get_all_feature_states() serialized_flags = FeatureStateSerializerFull(all_feature_states, many=True) serialized_traits = TraitSerializerBasic( identity.identity_traits.all(), 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)
class IdentitySerializerTraitFlags(serializers.Serializer): flags = FeatureStateSerializerFull(many=True) traits = TraitSerializerBasic(many=True)