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
