class ConfigurationSerializer(serializers.Serializer): priority = fields.ChoiceField(PRIORITY) scheduler = fields.ChoiceField(SCHEDULER_TYPE) max_tasks = fields.IntegerField(min_value=1) weight = fields.ChoiceField(DECISION_WEIGHT) parallelism = fields.ListField(child=fields.RegexField(r'^\d+(\.\d+)?$'), min_length=4, max_length=4) memory = fields.FloatField() cpu_num = fields.IntegerField(allow_null=True, min_value=1) disk_size = fields.FloatField() cpu_model = fields.CharField(default='', allow_null=True, allow_blank=True) cpu_time_exec_cmds = fields.FloatField() memory_exec_cmds = fields.FloatField() console_level = fields.ChoiceField(LOGGING_LEVELS) file_level = fields.ChoiceField(LOGGING_LEVELS) console_formatter = fields.CharField() file_formatter = fields.CharField() keep_intermediate_files = fields.BooleanField() upload_verifier_files = fields.BooleanField() upload_other_files = fields.BooleanField() ignore_subjobs = fields.BooleanField() total_coverage = fields.BooleanField() coverage_details = fields.ChoiceField(COVERAGE_DETAILS) def create(self, validated_data): raise NotImplementedError def update(self, instance, validated_data): raise NotImplementedError
class HistorySerializerMixIn(Serializer): history_id = fields.IntegerField() history_date = fields.DateTimeField() history_change_reason = fields.CharField() history_type = fields.CharField() history_user_id = fields.IntegerField() history_user = UserSerializer() class Meta: fields = ('history_id', 'history_date', 'history_change_reason', 'history_type', 'history_type', 'history_user_id', 'history_user') def to_representation(self, instance): ret = OrderedDict() fields = self._readable_fields # noqa for field in fields: simplify_nested_serializer(field) try: attribute = field.get_attribute(instance) if attribute is not None: ret[field.field_name] = field.to_representation(attribute) else: ret[field.field_name] = None except AttributeError: ret[field.field_name] = None return ret
class BadgeSerializer(serializers.ModelSerializer): """The badge serializer """ badge_type = fields.SerializerMethodField() award_count = fields.IntegerField(source='users__count') rank = fields.SerializerMethodField() badge_id = fields.IntegerField(source='pk') class Meta: model = models.Badge fields = ('badge_type', 'award_count', 'rank', 'badge_id', 'name') @staticmethod def get_badge_type(badge: models.Badge) -> str: """Get the badge type. :param badge: The badges. :return: The badge type. """ return "tag_based" if badge.tag_based else "named" @staticmethod def get_rank(badge: models.Badge) -> str: """Get the badge rank. :param badge: The badges. :return: The badge type. """ for class_id, class_description in models.Badge.CLASS_CHOICES: if badge.badge_class == class_id: return class_description
class CreateSightingSerializer(serializers.ModelSerializer): id = fields.IntegerField(read_only=True) pk = fields.IntegerField(read_only=True) photo_url = JsonBase64ImageFileField(required=False, max_length=512) class Meta: model = Sighting fields = ( 'pk', 'id', 'accuracy', 'activity', 'count', 'depth', 'habitat', 'latitude', 'longitude', 'notes', 'other_species', 'photo_caption', 'photo_url', 'sex', 'sighting_date', 'size', 'size_method', 'species', 'time', 'water_temperature', 'weight', 'weight_method', )
class StockTransferOutSerializer(ModelSerializer): id = fields.CharField(required=False) detail = StockTransferOutDetailSerializer(source='list_detail', many=True, read_only=True) created_at = fields.DateTimeField(read_only=True) created_by_detail = UserSerializer(read_only=True, source='created_by') created_by__id = fields.CharField(read_only=True) total = fields.IntegerField(read_only=True) promotion__id = fields.IntegerField(required=False, read_only=True) promotion_detail = PromotionSerializer(read_only=True, source='promotion') customer_detail = CustomerSerializer(read_only=True, source='customer') customer__id = fields.CharField(read_only=True) def validate_promotion_code(self, promotion_code): if promotion_code is None or promotion_code == "": return None promotions = Promotion.objects.filter(code=promotion_code) if promotions.count() == 0: raise ValidationError('promotion does not exist') if promotions[0].is_used: raise ValidationError('promotion is used') return promotion_code class Meta: model = StockTransferOut fields = '__all__'
class NoticeFilterSerializer(serializers.Serializer): offset = fields.IntegerField(required=False, default=0, min_value=0) limit = fields.IntegerField(required=False, default=3, min_value=0, max_value=10) date_after = fields.IntegerField(required=False, default=0, min_value=0)
def test_options_mapping(self, assert_dict_equals): """ Confirm that new serializers will catch and correctly manage field options for its specified model, for non-embedded models """ class TestSerializer(DjongoModelSerializer): class Meta: model = OptionsModel fields = '__all__' expected_dict = { # Primary keys should be made read-only, with the db column being # ignored entirely "db_column_id": rmd_fields.ObjectIdField(read_only=True), # Nullable and blank values should have required=False appended. # The prior requires a unique validator as well, the text requires # templates "null_char": ("CharField(allow_null=True, " "required=False, " "validators=[<django.core.validators.MaxLengthValidator object>])" ), "blank_char": drf_fields.CharField(allow_blank=True, required=False, style={'base_template': 'textarea.html'}), # Fields with choices should be coerced into that form of field "choice_char": "ChoiceField(choices=['Foo', 'Bar', 'Baz'], " "validators=[<django.core.validators.MaxLengthValidator object>])", # Defaults are handled by Django, not DRF, so the argument should # be stripped implicitly (though it still is in use during save!) # This will set required=False, however "default_email": drf_fields.EmailField(max_length=254, required=False), # Read only fields should be marked as such "read_only_int": drf_fields.IntegerField(read_only=True), # Errors, by default, should be distinct between DRF and Djongo; # Therefore, it should be stripped unless explicitly set in the # serializer by the user "custom_error": drf_fields.IntegerField(max_value=2147483647, min_value=-2147483648), # Help text should be conserved "help_char": ("CharField(help_text='Super helpful text', " "validators=[<django.core.validators.MaxLengthValidator object>])" ), # Fields designated as unique should have a validator stating # such added "unique_int": ("IntegerField(max_value=2147483647, " "min_value=-2147483648, " "validators=[<UniqueValidator(queryset=OptionsModel.objects.all())>])" ), } assert_dict_equals(TestSerializer().get_fields(), expected_dict)
class VodRequestSerializer(serializers.Serializer): deck_id = fields.CharField(required=False) user_id = fields.IntegerField(required=False) archetype_id = fields.IntegerField(required=False) def validate_deck_id(self, value): if not value: return None try: if value.isdigit(): deck = Deck.objects.get(id=value) else: deck = Deck.objects.get_by_shortid(value) except Deck.DoesNotExist: raise serializers.ValidationError("Invalid deck ID") if not deck.is_full_deck: raise serializers.ValidationError("Invalid deck ID") return deck.id def validate_user_id(self, value): if not value: return None User = get_user_model() try: user = User.objects.get(pk=value) except User.DoesNotExist: raise serializers.ValidationError("Invalid user ID") return user.id def validate_archetype_id(self, value): if not value: return None try: archetype = Archetype.objects.get(id=value) except Archetype.DoesNotExist: raise serializers.ValidationError("Invalid archetype ID") return archetype.id def validate(self, data): fields = ["user_id", "deck_id", "archetype_id"] field_data = [data.get(field, None) for field in fields] valid_fields = sum(1 for field in field_data if field) if valid_fields < 1: raise serializers.ValidationError("%s must be specified." % " or ".join(fields)) if valid_fields > 1: raise serializers.ValidationError( "Too many identifiers. Only %s must be specified." % " or ".join(fields)) return data
class NetworkCreateSerializer(NetworkSerializer): """Used for POST on Networks.""" cidr = fields.CharField( write_only=True, required=False, label='CIDR', help_text=( 'IPv4/IPv6 CIDR address. If provided, this overrides the value of ' 'network_address & prefix_length. If not provided, ' 'network_address & prefix_length are required.' ) ) network_address = fields.ModelField( model_field=models.Network._meta.get_field('network_address'), required=False, label=get_field_attr( models.Network, 'network_address', 'verbose_name' ), help_text=get_field_attr( models.Network, 'network_address', 'help_text' ), ) prefix_length = fields.IntegerField( required=False, label=get_field_attr(models.Network, 'prefix_length', 'verbose_name'), help_text=get_field_attr(models.Network, 'prefix_length', 'help_text'), ) site_id = fields.IntegerField( label=get_field_attr(models.Network, 'site', 'verbose_name'), help_text=get_field_attr(models.Network, 'site', 'help_text') ) class Meta: model = models.Network fields = ('cidr', 'network_address', 'prefix_length', 'attributes', 'state', 'site_id')
class MerchandiseSerializer(ModelSerializer): id = fields.CharField(required=False) type_detail = MerchandiseTypeSerializer(source='type', read_only=True) merchandise_type = fields.IntegerField(read_only=True) available_count = fields.IntegerField(read_only=True) type__id = fields.CharField(read_only=True) class Meta: model = Merchandise fields = '__all__'
class CustomerTypeSerializer(ModelSerializer): id = fields.CharField(required=False) min = fields.IntegerField(default=0) max = fields.IntegerField(default=0) type = fields.CharField(max_length=64) descriptions = fields.CharField(max_length=256) class Meta: model = CustomerType fields = '__all__'
class PollResponseSerializer(serializers.MongoEngineModelSerializer): phone = fields.CharField(source='phone_no') time = fields.DateTimeField(source='received_at') relayer = fields.IntegerField(source='relayer_id') run = fields.IntegerField(source='run_id') source = serialiserzz.Field(source='source') location = serialiserzz.Field(source='location_str') class Meta: model = PollResponse fields = ('id', 'phone', 'time', 'relayer', 'run', 'text', 'source', 'location', 'poll')
class RapidProMessageSerializer(serializers.MongoEngineModelSerializer): phone = fields.CharField(source='phone_no') time = RapidProDateTimeField(source='received_at') relayer = fields.IntegerField(source='relayer_id') run = fields.IntegerField(source='run_id') source = serialiserzz.Field(source='source') profile_id = serialiserzz.Field(source='profile_id') location = serialiserzz.Field(source='location_str') class Meta: model = RapidProMessage fields = ('id', 'phone', 'time', 'relayer', 'run', 'text', 'source', 'location', 'disaster', 'profile_id', 'auto_associated')
class VodSerializer(serializers.Serializer): """A serializer to extract from a TwitchVod model instance""" channel_name = fields.CharField(source="twitch_channel_name") url = fields.URLField() game_date = TimestampField(precision=1) game_type = fields.CharField() rank = fields.IntegerField() legend_rank = fields.IntegerField(allow_null=True) friendly_player_archetype_id = fields.IntegerField(allow_null=True) opposing_player_class = fields.CharField() opposing_player_archetype_id = fields.IntegerField(allow_null=True) won = fields.BooleanField() went_first = fields.BooleanField() game_length_seconds = fields.IntegerField() replay_shortid = fields.CharField()
class CardboardWishSerializer(serializers.ModelSerializer): created_at = serializers.DateTimeField(read_only=True, format=JAVASCRIPT_DATETIME_FORMAT) updated_at = serializers.DateTimeField(read_only=True, format=JAVASCRIPT_DATETIME_FORMAT) requirements = RequirementSerializer(many=True, read_only=True) wish_id = fields.IntegerField(write_only=True) cardboard = CardboardNameSerializer(validators=[_validate_cardboard_name], source='cardboard_name') minimum_amount = fields.IntegerField(required=False) class Meta: model = models.CardboardWish fields = ('id', 'cardboard', 'minimum_amount', 'requirements', 'created_at', 'updated_at', 'wish_id')
class ProfileSerializer(serializers.DocumentSerializer): name = fields.CharField(required=False) age = fields.IntegerField(required=False) class Meta: model = models.Profile fields = ['id', 'name', 'age']
def test_inherited_field_nullable(self, assert_dict_equals): """ Confirm the fields declared in a serializer that another serializer inherits from can still be ignored by setting them to `None` in the child serializer """ class TestSerializer(DjongoModelSerializer): missing = ReadOnlyField() class Meta: model = ObjIDModel fields = '__all__' class ChildSerializer(TestSerializer): missing = None class Meta(TestSerializer.Meta): pass expected_dict = { '_id': rmd_fields.ObjectIdField(read_only=True), 'int_field': drf_fields.IntegerField(max_value=2147483647, min_value=-2147483648), 'char_field': drf_fields.CharField(max_length=5), } assert_dict_equals(ChildSerializer().get_fields(), expected_dict)
class LotesSerializer(serializers.EmbeddedDocumentSerializer): existencia = fields.IntegerField(required=True) fecha_vencimiento = fields.DateField(required=False) class Meta: model = Lote fields = "__all__"
class CopyPageAPIActionSerializer(Serializer): # Note: CopyPageAction will validate the destination page destination_page_id = fields.IntegerField(required=False) recursive = fields.BooleanField(default=False, required=False) keep_live = fields.BooleanField(default=True, required=False) slug = fields.CharField(required=False) title = fields.CharField(required=False)
class OccurrenceSerializer(serializers.HyperlinkedModelSerializer): id = fields.IntegerField(read_only=True) url = fields.SerializerMethodField() methods = fields.SerializerMethodField() _methods_cache = None # class attribute that caches methdos for the OccurrenceViewSet class Meta: model = Occurrence def get_methods(self, occ): from views import OccurrenceViewSet # @NoMove methods = OccurrenceSerializer._methods_cache or get_detail_routes( OccurrenceViewSet) OccurrenceSerializer._methods_cache = methods method_dict = {} lookups = occ.get_lookups() for method in methods: url_name = "occurrence-{0}".format(method) try: url = reverse(url_name, args=lookups.values(), request=self._context['request']) except NoReverseMatch: pass else: method_dict[method] = url return method_dict def get_url(self, occ): lookups = occ.get_lookups() return reverse('occurrence-detail', args=lookups.values(), request=self._context['request'])
class NetworkCreateSerializer(NetworkSerializer): """Used for POST on Networks.""" cidr = fields.CharField(write_only=True) site_id = fields.IntegerField() class Meta: model = models.Network fields = ('cidr', 'attributes', 'site_id') def create(self, validated_data): # Remove the related fields before we write the object attributes = validated_data.pop('attributes', {}) obj = super(NetworkCreateSerializer, self).create(validated_data) # Try to populate the related fields and if there are any validation # problems, delete the object and re-raise the error. If not, save the # changes. try: obj.set_attributes(attributes) except exc.ValidationError: obj.delete() raise else: obj.save() return obj
class UserBadgeSerializer(serializers.ModelSerializer): """The user badge serializer """ user = BaseUserSerializer() name = fields.CharField(source='badge.name') badge_type = fields.SerializerMethodField(source='badge.badge_type') rank = fields.SerializerMethodField(source='badge.rank') badge_id = fields.IntegerField(source='pk') class Meta: model = models.UserBadge fields = ('user', 'badge_type', 'rank', 'badge_id', 'name') @staticmethod def get_badge_type(user_badge: models.UserBadge) -> str: """Get the user badge type. :param user_badge: The badges. :return: The badge type. """ return "tag_based" if user_badge.badge.tag_based else "named" @staticmethod def get_rank(user_badge: models.UserBadge) -> str: """Get the user badge rank. :param user_badge: The badges. :return: The badge type. """ for class_id, class_description in models.Badge.CLASS_CHOICES: if user_badge.badge.badge_class == class_id: return class_description
class FacebookSerializer(serializers.Serializer): id = fields.IntegerField(read_only=True) access_token = fields.CharField(max_length=255) auth_token = fields.CharField(max_length=255, read_only=True) def save(self, **kwargs): pass
def get_extend_param_fields(cls): assert 0 < cls.DEFAULT_PAGE_SIZE <= cls.PAGE_SIZE_MAX, ( "DEFAULT_PAGE_SIZE mast between 0 and PAGE_SIZE_MAX in class %s" % cls.__name__) return super().get_extend_param_fields() + ( ('page', fields.IntegerField(label=gettext_lazy('Page number'), default=1, help_text=gettext_lazy('Start with %(start)s') % {'start': 1})), ('page_size', fields.IntegerField(label=gettext_lazy('Page size'), default=cls.DEFAULT_PAGE_SIZE, min_value=1, max_value=cls.PAGE_SIZE_MAX)), )
class CarSerializer(serializers.ModelSerializer): id = fields.IntegerField(required=True) plates = fields.CharField(read_only=True) class Meta: model = Car fields = ("id", "plates", "fuel_consumption", "description")
class CounterItemSerializer(ModelSerializer): count = fields.IntegerField(required=True) class Meta: model = CounterItem fields = ['id', 'count']
def get_fields(self): flds = {f : fields.IntegerField() for f in ["articles", "done","error"]} flds["plugin_id"] = relations.PrimaryKeyRelatedField(queryset=Plugin.objects.all()) flds[ "article__articlesets_set"] = relations.PrimaryKeyRelatedField(queryset=ArticleSet.objects.all()) flds["article__articlesets_set__project"] = relations.PrimaryKeyRelatedField(queryset=Project.objects.all()) return flds
class StockTransferInSerializer(ModelSerializer): id = fields.CharField(required=False) detail = StockTransferInDetailSerializer(source='list_detail', many=True, read_only=True) created_at = fields.DateTimeField(read_only=True) total = fields.IntegerField(read_only=True) dept = fields.IntegerField(read_only=True) supplier_detail = SupplierSerializer(read_only=True, source='supplier') created_by_detail = UserSerializer(read_only=True, source='created_by') created_by__id = fields.CharField(read_only=True) supplier__id = fields.CharField(read_only=True) class Meta: model = StockTransferIn fields = '__all__'
class QuoteSerializer(serializers.Serializer): id = fields.IntegerField(read_only=True) text = fields.CharField() author = fields.CharField(max_length=300) def create(self, validated_data): return Quote.objects.create(**validated_data)
class DeviceCreateSerializer(DeviceSerializer): """Used for POST on Devices.""" site_id = fields.IntegerField() class Meta: model = models.Device fields = ('hostname', 'attributes', 'site_id') def create(self, validated_data): # Remove the related fields before we write the object attributes = validated_data.pop('attributes', {}) # Save the base object to the database. obj = super(DeviceCreateSerializer, self).create(validated_data) # Try to populate the related fields and if there are any validation # problems, delete the object and re-raise the error. If not, save the # changes. try: obj.set_attributes(attributes) except exc.ValidationError: obj.delete() raise else: obj.save() return obj