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 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 TransactionSerializer(serializers.ModelSerializer): prison = PrisonSerializer(required=False) credited = fields.BooleanField() refunded = fields.BooleanField() blocked = fields.BooleanField() class Meta: model = Transaction fields = ( 'id', 'prison', 'amount', 'sender_sort_code', 'sender_account_number', 'sender_name', 'sender_roll_number', 'reference', 'credited', 'refunded', 'received_at', 'category', 'source', 'ref_code', 'reference_in_sender_field', 'blocked', )
class UserSerializer(Serializer): email = fields.EmailField() lastname = fields.CharField() firstname = fields.CharField() is_active = fields.BooleanField(default=False) is_superuser = fields.BooleanField(default=False) is_staff = fields.BooleanField(default=True)
class ReconcileTransactionSerializer(serializers.ModelSerializer): prison = PrisonSerializer(required=False) credited = fields.BooleanField() refunded = fields.BooleanField() class Meta: model = Transaction fields = ('id', 'prison', 'amount', 'credited', 'refunded', 'received_at', 'category', 'source', 'ref_code')
class DecisionSerializer(serializers.ModelSerializer): tasks_started = fields.BooleanField(default=False, write_only=True) tasks_finished = fields.BooleanField(default=False, write_only=True) subjobs_started = fields.BooleanField(default=False, write_only=True) subjobs_finished = fields.BooleanField(default=False, write_only=True) start_ts = TimeStampField(read_only=True) finish_ts = TimeStampField(read_only=True) start_sj = TimeStampField(read_only=True) finish_sj = TimeStampField(read_only=True) start_date = TimeStampField(read_only=True) finish_date = TimeStampField(read_only=True) status = fields.CharField(read_only=True) def update(self, instance, validated_data): assert isinstance(instance, Decision) # Set current date current_date = now() if validated_data.pop('tasks_started', False) and not instance.start_ts: validated_data['start_ts'] = current_date if validated_data.pop('tasks_finished', False) and not instance.finish_ts: validated_data['finish_ts'] = current_date if validated_data.pop('subjobs_started', False) and not instance.start_sj: validated_data['start_sj'] = current_date if validated_data.pop('subjobs_finished', False) and not instance.finish_sj: validated_data['finish_sj'] = current_date # Both time and gag can't exist if 'expected_time_ts' in validated_data: validated_data['gag_text_ts'] = None elif 'gag_text_ts' in validated_data: validated_data['expected_time_ts'] = None # Both time and gag can't exist if 'expected_time_sj' in validated_data: validated_data['gag_text_sj'] = None elif 'gag_text_sj' in validated_data: validated_data['expected_time_sj'] = None return super().update(instance, validated_data) class Meta: model = Decision fields = ('total_sj', 'failed_sj', 'solved_sj', 'total_ts', 'failed_ts', 'solved_ts', 'tasks_started', 'tasks_finished', 'subjobs_started', 'subjobs_finished', 'expected_time_sj', 'gag_text_sj', 'expected_time_ts', 'gag_text_ts', 'start_ts', 'finish_ts', 'start_sj', 'finish_sj', 'start_date', 'finish_date', 'status')
class ProductSerializer(Serializer): pk = fields.IntegerField() reference = fields.CharField() collection = CollectionSerializer() images = ImageSerializer(many=True) variant = VariantSerializer(many=True) name = fields.CharField() in_stock = fields.BooleanField() our_favorite = fields.BooleanField() is_discounted = fields.BooleanField() price_pre_tax = fields.DecimalField(5, 2) discounted_price = fields.DecimalField(5, 2) slug = fields.SlugField()
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 PromotionSerializer(ModelSerializer): id = fields.CharField(required=False) is_used = fields.BooleanField(read_only=True) class Meta: model = Promotion fields = '__all__'
class ProductSerializer(Serializer): collection = CollectionSerializer() images = ImageSerializer(many=True) clothe_size = ClotheSizeSerializer(many=True) name = fields.CharField() in_stock = fields.BooleanField() slug = fields.SlugField()
class JobDetailSerializer(BookmarkedJobSerializer, InClusterMixin, TagsSerializerMixin, DataRefsSerializerMixin, NamesMixin): resources = fields.SerializerMethodField() merge = fields.BooleanField(write_only=True, required=False) class Meta(BookmarkedJobSerializer.Meta): fields = BookmarkedJobSerializer.Meta.fields + ( 'merge', 'is_clone', 'original_job', 'description', 'readme', 'config', 'in_cluster', 'resources', 'data_refs', 'node_scheduled', ) extra_kwargs = {'original_job': {'write_only': True}} def get_resources(self, obj): return obj.resources.to_dict() if obj.resources else None def update(self, instance, validated_data): validated_data = self.validated_tags(validated_data=validated_data, tags=instance.tags) validated_data = self.validated_data_refs( validated_data=validated_data, data_refs=instance.data_refs) validated_data = self.validated_name(validated_data, project=instance.project, query=Job.all) return super().update(instance=instance, validated_data=validated_data)
class RepositorySyncURLSerializer(ValidateFieldsMixin, serializers.Serializer): remote = DetailRelatedField( required=False, view_name_pattern=r"remotes(-.*/.*)-detail", queryset=models.Remote.objects.all(), help_text= _("A remote to sync from. This will override a remote set on repository." ), ) mirror = fields.BooleanField( required=False, default=False, help_text= _("If ``True``, synchronization will remove all content that is not present in " "the remote repository. If ``False``, sync will be additive only."), ) def validate(self, data): data = super().validate(data) try: remote = models.Repository.objects.get( pk=self.context["repository_pk"]).remote except KeyError: remote = None if "remote" not in data and not remote: raise serializers.ValidationError({ "remote": _("This field is required since a remote is not set on the repository." ) }) return data
class JobDetailSerializer(BookmarkedJobSerializer, TagsSerializerMixin): original = fields.SerializerMethodField() resources = fields.SerializerMethodField() merge = fields.BooleanField(write_only=True, required=False) class Meta(BookmarkedJobSerializer.Meta): fields = BookmarkedJobSerializer.Meta.fields + ( 'merge', 'is_clone', 'original', 'original_job', 'description', 'config', 'resources', 'node_scheduled', ) extra_kwargs = {'original_job': {'write_only': True}} def get_original(self, obj): return obj.original_job.unique_name if obj.original_job else None def get_resources(self, obj): return obj.resources.to_dict() if obj.resources else None def update(self, instance, validated_data): validated_data = self.validated_tags(validated_data=validated_data, tags=instance.tags) return super().update(instance=instance, validated_data=validated_data)
class ExperimentDetailSerializer(BookmarkedExperimentSerializer, InClusterMixin, TagsSerializerMixin, DataRefsSerializerMixin): resources = fields.SerializerMethodField() num_jobs = fields.SerializerMethodField() last_metric = fields.SerializerMethodField() merge = fields.BooleanField(write_only=True, required=False) class Meta(BookmarkedExperimentSerializer.Meta): fields = BookmarkedExperimentSerializer.Meta.fields + ( 'original_experiment', 'merge', 'readme', 'config', 'resources', 'in_cluster', 'run_env', 'data_refs', 'num_jobs', 'is_clone', 'code_reference', 'has_tensorboard', ) extra_kwargs = {'original_experiment': {'write_only': True}} def get_resources(self, obj): resources = obj.resources if resources and not isinstance(resources, dict): resources = resources.to_dict() return resources def get_num_jobs(self, obj): return obj.jobs__count def get_last_metric(self, obj): return {k: round(v, 7) for k, v in obj.last_metric.items() } if obj.last_metric else None def validated_declarations(self, validated_data, declarations): new_declarations = validated_data.get('declarations') if not validated_data.get( 'merge') or not declarations or not new_declarations: # This is the default behavior return validated_data declarations.update(new_declarations) validated_data['declarations'] = declarations return validated_data def update(self, instance, validated_data): validated_data = self.validated_tags(validated_data=validated_data, tags=instance.tags) validated_data = self.validated_data_refs( validated_data=validated_data, data_refs=instance.data_refs) validated_data = self.validated_declarations( validated_data=validated_data, declarations=instance.declarations) return super().update(instance=instance, validated_data=validated_data)
def test_basic_mapping(self, assert_dict_equals): """ Confirm that the serializer can still handle models w/ standard Django fields """ class TestSerializer(DjongoModelSerializer): class Meta: model = GenericModel fields = '__all__' expected_dict = { 'id': drf_fields.IntegerField(label='ID', read_only=True), 'big_int': drf_fields.IntegerField(max_value=9223372036854775807, min_value=-9223372036854775808), 'bool': drf_fields.BooleanField(), 'char': drf_fields.CharField(max_length=20), 'comma_int': ("CharField(validators=[<django.core.validators.RegexValidator " "object>, <django.core.validators.MaxLengthValidator object>])"), 'date': drf_fields.DateField(), 'date_time': drf_fields.DateTimeField(), 'decimal': drf_fields.DecimalField(decimal_places=5, max_digits=10), 'email': drf_fields.EmailField(max_length=254), 'float': drf_fields.FloatField(), 'integer': drf_fields.IntegerField(max_value=2147483647, min_value=-2147483648), 'null_bool': drf_fields.NullBooleanField(required=False), 'pos_int': drf_fields.IntegerField(max_value=2147483647, min_value=0), 'pos_small_int': drf_fields.IntegerField(max_value=32767, min_value=0), 'slug': drf_fields.SlugField(allow_unicode=False, max_length=50), 'small_int': drf_fields.IntegerField(max_value=32767, min_value=-32768), 'text': "CharField(style={'base_template': 'textarea.html'})", 'time': drf_fields.TimeField(), 'url': drf_fields.URLField(max_length=200), 'ip': drf_fields.IPAddressField(), 'uuid': "ModelField(model_field=<django.db.models.fields.UUIDField: uuid>)", } assert_dict_equals(TestSerializer().get_fields(), expected_dict)
class ImageSerializer(Serializer): pk = fields.IntegerField() name = fields.CharField() url = fields.URLField() web_url = fields.ImageField() # image_thumbnail = fields.ImageField() variant = fields.CharField() main_image = fields.BooleanField()
class BaseModelWithCreatedByAndSoftDeleteSerializer(BaseModelWithCreatedBySerializer): deleted = fields.BooleanField(read_only=True) def get_field_names(self, declared_fields, info): """ Overrides the default get_field_names method, and adds the deleted flag """ field_names = super(BaseModelWithCreatedByAndSoftDeleteSerializer, self).get_field_names(declared_fields, info) # add pk, display and content_type to this, as a set (enforcing uniqueness of those fields) return tuple(set(('deleted',) + field_names))
class UpdateRefundedTransactionSerializer(serializers.ModelSerializer): id = fields.IntegerField(required=True) refunded = fields.BooleanField(required=True) class Meta: model = Transaction list_serializer_class = UpdateTransactionListSerializer fields = ('id', 'refunded')
class RegisterSerializer(PostModelSerializer): join_mailing_list = fields.BooleanField(required=False) region = fields.ChoiceField(required=True) def __init__(self, *args, **kwargs): self.base_fields['region'].choices = tuple( [(None, '--None--')] + [(r.description, r.description) for r in Region.objects.all()]) super(RegisterSerializer, self).__init__(*args, **kwargs) def validate_email(self, data, field_name): """ Validate that the email is not already in use. """ existing = User.objects.filter(email__iexact=data['email']) if existing.exists(): raise fields.ValidationError( "A user with that email already exists.") else: return data def to_native(self, obj): ret = super(RegisterSerializer, self).to_native(obj) ret['join_mailing_list'] = obj.get_profile( ).joined_mailing_list_on_signup ret['region'] = obj.get_profile().region.description return ret def save(self, **kwargs): user = super(RegisterSerializer, self).save(**kwargs) user.set_password(user.password) user.save() profile = user.get_profile() try: profile.region = Region.objects.get( description=self.cleaned_data['region']) except Region.DoesNotExist: profile.region = None profile.joined_mailing_list_on_signup = self.cleaned_data[ 'join_mailing_list'] profile.save() return user class Meta: model = User postonly_fields = ('password', ) fields = ( 'username', 'password', 'email', 'first_name', 'last_name', 'join_mailing_list', 'region', )
class BikeListSerializer(serializers.ModelSerializer): model_year__gte = fields.IntegerField(min_value=1950, max_value=2100, required=False) model_year__lte = fields.IntegerField(min_value=1950, max_value=2100, required=False) price__gte = fields.IntegerField(min_value=0, max_value=4500, required=False) price__lte = fields.IntegerField(min_value=50, required=False) distance__gte = fields.IntegerField(min_value=0, max_value=100000, required=False) distance__lte = fields.IntegerField(min_value=0, required=False) payment_method = BikePaymentMethod() payment_method__card = fields.BooleanField(required=False) payment_method__lease = fields.BooleanField(required=False) page = fields.IntegerField(min_value=0, required=False) class Meta: model = Bike # 쿼리 옵션 https://docs.djangoproject.com/en/3.0/ref/models/querysets/ fields = ( 'model' 'deal_area', 'bike_style', 'model_year__gte', 'model_year__lte', 'price__gte', 'price__lte', 'driven_distance__gte', 'driven_distance__lte', 'payment_method', 'payment_method__card', 'payment_method__lease', 'page', ) extra_kwargs = { 'deal_area': required_false, 'model_year': required_false, } def to_representation(self, instance): return instance.get_info()
class Meta: param_fields = ( ('name', fields.CharField(label='名称', max_length=64)), ('description', fields.CharField(label='描述', max_length=255)), ('create_user_manager', fields.BooleanField(label='创建人管理权限', required=False, default=False)), )
class AdminSettingSerializer(serializers.MongoEngineModelSerializer): name = fields.CharField(source='name') yes_no = fields.BooleanField(source='yes_no', default=True) value_str = fields.CharField(source='value_str', required=False) value_int = fields.IntegerField(source='value_int', required=False) class Meta: model = AdminSetting fields = ('name', 'yes_no', 'value_str', 'value_int')
def str2bool(source, default=False): """str转换为bool True: "true", "True", "1", 1 False: "false", "False", "0", 0 """ try: return fields.BooleanField().to_internal_value(source) except ValidationError: return default
class AgreementPolicySerializer(serializers.ModelSerializer): rules = fields.BooleanField(required=True) tax = fields.BooleanField(required=True) agree = fields.BooleanField(required=True) class Meta: model = models.PolicyAgreement fields = ('id', 'rules', 'tax', 'agree') def validate(self, data): if 'rules' in data and 'tax' in data and 'agree' in data: if (data['rules']) is not True: raise serializers.ValidationError("rules must be accepted") if (data['tax']) is not True: raise serializers.ValidationError("tax must be accepted") if (data['agree']) is not True: raise serializers.ValidationError("agree must be accepted") return data
class RepairSerializer(serializers.Serializer, ValidateFieldsMixin): verify_checksums = fields.BooleanField( required=False, default=True, help_text= _("Will verify that the checksum of all stored files matches what saved in the " "database. Otherwise only the existence of the files will be checked. Enabled " "by default"), )
class ProjectDto(BaseDto): name = fields.CharField(max_length=255, required=True) archived = fields.BooleanField(required=False) @classmethod def from_model(cls, model: Project): dto = cls() dto.name = model.name dto.archived = model.archived return dto
class TopicSerializer(serializers.ModelSerializer): is_dead = fields.BooleanField(read_only=True) age = fields.CharField(read_only=True) text_dead = fields.CharField(read_only=True) topic_title = fields.SerializerMethodField('obj_topic_title') class Meta: model = Topic def obj_topic_title(self, obj): return html_parser.unescape(obj.topic_title)
class UserSerializer(ModelSerializer): id = fields.CharField(required=False) email = fields.EmailField(required=False) username = fields.CharField(required=False) first_name = fields.CharField(required=False, allow_blank=True, allow_null=True) last_name = fields.CharField(required=False, allow_blank=True, allow_null=True) last_login = fields.DateTimeField(required=False) date_joined = fields.DateTimeField(required=False) is_active = fields.BooleanField(required=False, default=True) is_staff = fields.BooleanField(required=False, default=True) is_superuser = fields.BooleanField(required=False, default=True) groups_ids = PrimaryKeyRelatedField(required=False, many=True, read_only=False, queryset=Group.objects.all(), source='groups') permissions_ids = PrimaryKeyRelatedField( required=False, many=True, read_only=False, queryset=Permission.objects.filter( Q(content_type__app_label='QuanLyNhaSach') | Q(content_type__app_label='auth')), source='user_permissions') class Meta: model = User fields = ('id', 'username', 'email', 'first_name', 'last_name', 'last_login', 'date_joined', 'is_active', 'groups_ids', 'permissions_ids', 'is_staff', 'is_superuser') databases_always_serialize = ('id', 'username', 'email', 'first_name', 'last_name', 'last_login', 'date_joined', 'is_active', 'groups_ids', 'permissions_ids', 'is_staff', 'is_superuser')
class EventMealVoteSerializer(serializers.Serializer): vote = fields.BooleanField(required=True) def save(self, **kwargs): meal_obj = kwargs.pop('meal_obj') user_id = kwargs.pop('user_id') if self.validated_data.get('vote'): # Create Vote meal_obj.votes.create(user_id=user_id) else: # Delete Vote meal_obj.votes.filter(user_id=user_id).delete() return meal_obj
class EventShoppingItemBringSerializer(serializers.Serializer): bring = fields.BooleanField(required=True) def save(self, **kwargs): item_obj = kwargs.pop('item_obj') user_id = kwargs.pop('user_id') if self.validated_data.get('bring'): # add bringer_id to shopping item object item_obj.bringer_id = user_id else: # remove bringer_id to shopping item object item_obj.bringer_id = "" item_obj.save() return item_obj