class FilterSerilizer(serializers.Serializer):
canton = serializers.ChoiceField(choices=CANTONS, required=False)
rooms = serializers.ChoiceField(choices=ROOMS, required=False)
sqm_start = serializers.IntegerField(
max_value=400,
min_value=50,
default=50,
)
sqm_end = serializers.IntegerField(
max_value=400,
min_value=50,
default=400,
)
bathroom = serializers.ChoiceField(choices=BATHROOM, required=False)
rental_period = serializers.ChoiceField(choices=RENTAL_PERIOD,
required=False)
balcony = serializers.NullBooleanField(required=False, )
elevator = serializers.NullBooleanField(required=False, )
housing_type = serializers.ChoiceField(choices=PROPERTY_TYPE,
required=False)
guests_allowed = serializers.NullBooleanField(required=False, )
smoking = serializers.NullBooleanField(required=False, )
class TwitterTailoredAudienceSerializer(serializers.ModelSerializer):
tw_account_id = PKRelatedField(queryset=TwitterAccount.objects_raw.all())
name = serializers.CharField(required=True, allow_blank=False)
audience_size = serializers.CharField(required=False, allow_blank=False)
targetable_types = serializers.CharField(
required=False,
validators=[BaseValidator.JSONValidator],
allow_blank=True)
audience_type = serializers.CharField(required=False, allow_blank=False)
targetable = serializers.NullBooleanField()
list_type = serializers.CharField(required=False, allow_blank=False)
reasons_not_targetable = serializers.CharField(
required=False,
validators=[BaseValidator.JSONValidator],
allow_blank=True)
partner_source = serializers.CharField(required=False, allow_blank=False)
is_owner = serializers.NullBooleanField()
permission_level = serializers.CharField(required=False, allow_blank=False)
status = ChoiceCaseInsensitiveField(choices=STATUS_CHOICES, required=False)
created_at = DateTimeField(read_only=True)
last_update = DateTimeField(read_only=True)
class Meta:
model = TwitterTailoredAudience
fields = ('tw_targeting_id', 'tw_account_id', 'name', 'audience_size',
'targetable_types', 'audience_type', 'targetable',
'list_type', 'reasons_not_targetable', 'partner_source',
'is_owner', 'permission_level', 'status', 'created_at',
'last_update')
validators = [
serializers.UniqueTogetherValidator(
queryset=TwitterTailoredAudience.objects_raw.all(),
fields=('tw_targeting_id', ))
]
class PeHostSessionRestoreSerializer(serializers.Serializer):
host_snapshot_id = serializers.IntegerField(required=True)
type = serializers.ChoiceField(required=True,
choices=xdata.SNAPSHOT_TYPE_CHOICES)
disks = PeHostSessionRestoreDiskSerializer(many=True, required=True)
adapters = serializers.ListField(
required=True,
child=HostSnapshotRestoreAdapterSettingSerializer(required=True))
drivers_ids = serializers.JSONField(required=True)
agent_user_info = serializers.CharField(required=True)
routers = serializers.JSONField(required=True)
disable_fast_boot = serializers.NullBooleanField(required=False,
default=False)
replace_efi = serializers.NullBooleanField(required=False, default=False)
htb_task_uuid = serializers.CharField(required=False,
allow_null=True,
default=None)
exclude_volumes = serializers.ListField(
required=False,
allow_null=True,
default=list(),
child=HostSnapshotRestoreVolumeSerializer())
# 界面传入的时间，用作日志的记录。可能不是真正的还原时间点
restore_time = serializers.DateTimeField(required=False,
allow_null=True,
default=None)
remote_kvm_params = serializers.JSONField(required=False,
allow_null=True,
default=None)
class TRRNewTimelineMobileSerializer(BaseTimelineMobileSerializer):
trr_id = serializers.IntegerField(source='id')
date_sort = serializers.SerializerMethodField()
date = serializers.SerializerMethodField()
taser = serializers.NullBooleanField()
firearm_used = serializers.NullBooleanField()
point = serializers.SerializerMethodField()
def get_kind(self, obj):
return 'FORCE'
def get_priority_sort(self, obj):
return 50
def get_date_sort(self, obj):
return obj.trr_datetime.date()
def get_date(self, obj):
return obj.trr_datetime.date().strftime('%Y-%m-%d')
def get_point(self, obj):
try:
return {'lon': obj.point.x, 'lat': obj.point.y}
except AttributeError:
return None
class GuestSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
wedding_rsvp = serializers.NullBooleanField()
sunday_brunch = serializers.NullBooleanField(required=False)
rehearsal_rsvp = serializers.NullBooleanField(required=False)
class Meta:
model = Guest
fields = (
'id',
'first_name',
'last_name',
'wedding_rsvp',
'rehearsal_rsvp',
'sunday_brunch',
'invitation',
'is_plus_one',
)
def validate(self, data):
if self.context['request'].method == 'POST':
invitation = data.get('invitation')
# assert that given invitation allows for a plus one
if invitation and not invitation.plus_one:
raise serializers.ValidationError(
"Guest cannot be added to given invitation. Invitation does not provide for a plus one."
)
return super().validate(data)
class ProductionDataInputSerializer(serializers.Serializer):
"""
Serializer for validating the input of the production data endpoint
Does not need the save and update methods
"""
time = serializers.DateTimeField(
help_text=
"When the production data was generated. Example: 2016-11-04T08:45:15")
startlat = serializers.FloatField(
help_text="Start latitude. Example: 63.3870750023729")
startlong = serializers.FloatField(
help_text="Start longitute. Example: 10.3277250005425")
endlat = serializers.FloatField(
help_text="End latitude. Example: 63.3874419990294")
endlong = serializers.FloatField(
help_text="End longitude. Example: 10.3290930003037")
dry_spreader_active = serializers.NullBooleanField(
required=False, help_text="Dry spreader active boolean. Optional.")
plow_active = serializers.NullBooleanField(
required=False, help_text="Plow boolean. Optional.")
wet_spreader_active = serializers.NullBooleanField(
required=False, help_text="Wet spreader boolean. Optional.")
brush__active = serializers.NullBooleanField(
required=False, help_text="Brush boolean. Optional.")
material_type_code = serializers.IntegerField(
allow_null=True,
required=False,
help_text="Material type boolean. Optional")
class TRRSerializer(NoNullSerializer):
id = serializers.IntegerField()
to = serializers.SerializerMethodField()
taser = serializers.NullBooleanField()
firearm_used = serializers.NullBooleanField()
address = serializers.SerializerMethodField()
officer = serializers.SerializerMethodField()
trr_datetime = serializers.DateTimeField(format='%Y-%m-%d',
default_timezone=pytz.utc)
point = serializers.SerializerMethodField()
category = serializers.SerializerMethodField()
def get_point(self, obj):
return {
'lon': obj.point.x,
'lat': obj.point.y
} if obj.point is not None else None
def get_category(self, obj):
return obj.force_types[0] if len(obj.force_types) > 0 else 'Unknown'
def get_to(self, obj):
return f'/trr/{obj.id}/'
def get_address(self, obj):
return ' '.join(filter(None, [obj.block, obj.street]))
def get_officer(self, obj):
return CoaccusedSerializer(obj.officer).data
class VectorProviderSerializer(BaseProviderSerializer):
driver = serializers.CharField(
max_length=64,
required=True
)
parameters = serializers.JSONField(
required=True
)
properties = serializers.JSONField(
required=False,
)
clipped = serializers.NullBooleanField(
required=False,
)
projected = serializers.NullBooleanField(
required=False,
)
precision = serializers.IntegerField(
required=False,
min_value=1,
max_value=8
)
spacing = serializers.IntegerField(
required=False
)
class Meta:
fields = '__all__'
class NewThreadSerializer(serializers.Serializer):
title = serializers.CharField()
category = serializers.IntegerField()
weight = serializers.IntegerField(
required=False,
allow_null=True,
max_value=Thread.WEIGHT_GLOBAL,
min_value=Thread.WEIGHT_DEFAULT,
)
is_hidden = serializers.NullBooleanField(required=False)
is_closed = serializers.NullBooleanField(required=False)
def validate_title(self, title):
return validate_title(title)
def validate_category(self, category_id):
self.category = validate_category(self.context, category_id)
if not can_start_thread(self.context, self.category):
raise ValidationError(_("You can't create new threads in selected category."))
return self.category
def validate_weight(self, weight):
try:
add_acl(self.context, self.category)
except AttributeError:
return weight # don't validate weight further if category failed
if weight > self.category.acl.get('can_pin_threads', 0):
if weight == 2:
raise ValidationError(
_("You don't have permission to pin threads globally in this category.")
)
else:
raise ValidationError(
_("You don't have permission to pin threads in this category.")
)
return weight
def validate_is_hidden(self, is_hidden):
try:
add_acl(self.context, self.category)
except AttributeError:
return is_hidden # don't validate hidden further if category failed
if is_hidden and not self.category.acl.get('can_hide_threads'):
raise ValidationError(_("You don't have permission to hide threads in this category."))
return is_hidden
def validate_is_closed(self, is_closed):
try:
add_acl(self.context, self.category)
except AttributeError:
return is_closed # don't validate closed further if category failed
if is_closed and not self.category.acl.get('can_close_threads'):
raise ValidationError(
_("You don't have permission to close threads in this category.")
)
return is_closed
class HostSnapshotRestoreSerializer(serializers.Serializer):
type = serializers.ChoiceField(required=True,
choices=xdata.SNAPSHOT_TYPE_CHOICES)
# 整机还原目标主机
pe_host_ident = serializers.CharField(max_length=32,
required=False,
default=None,
allow_null=True)
disks = HostSnapshotRestoreDiskSerializer(many=True,
required=False,
default=None,
allow_null=True)
restore_time = serializers.DateTimeField(required=False,
allow_null=True,
default=None)
adapters = serializers.ListField(
required=False,
child=HostSnapshotRestoreAdapterSettingSerializer(required=True),
allow_null=True,
default=None)
# 为还原到Agent主机时传递
host_ident = serializers.CharField(max_length=32,
required=False,
allow_null=True,
default=None)
drivers_ids = serializers.JSONField(required=False,
allow_null=True,
default=None)
agent_user_info = serializers.CharField(required=False,
allow_null=True,
default=None)
routers = serializers.JSONField(required=False,
allow_null=True,
default=None)
disable_fast_boot = serializers.NullBooleanField(required=False,
default=False)
replace_efi = serializers.NullBooleanField(required=False, default=False)
htb_task_uuid = serializers.CharField(required=False,
allow_null=True,
default=None)
# 整机还原时排除的卷
exclude_volumes = serializers.ListField(
required=False,
allow_null=True,
default=None,
child=HostSnapshotRestoreVolumeSerializer())
# 卷还原时需要还原的卷
volumes = serializers.ListField(
required=False,
allow_null=True,
default=None,
child=HostSnapshotRestoreVolumeSerializer())
remote_kvm_params = serializers.JSONField(required=False,
allow_null=True,
default=None)
class IsPushForm(serializers.Serializer):
is_push = serializers.NullBooleanField(required=False, )
is_user_push = serializers.NullBooleanField(required=False, )
def validate(self, attrs):
if attrs.get('is_push') is None and attrs.get('is_user_push') is None:
raise serializers.ValidationError(
"is_push or is_user_push is required.")
return attrs
class UniprotEntryMappingSerializer(serializers.Serializer):
uniprotAccession = serializers.CharField()
entryType = serializers.CharField()
sequenceVersion = serializers.IntegerField()
upi = serializers.CharField()
md5 = serializers.CharField()
isCanonical = serializers.NullBooleanField()
alias = serializers.CharField()
ensemblDerived = serializers.NullBooleanField()
gene_symbol = serializers.CharField()
gene_accession = serializers.CharField()
length = serializers.IntegerField()
class UserSerializer(serializers.ModelSerializer):
password = serializers.CharField(max_length=128, write_only=True)
is_truck = serializers.NullBooleanField(source='truck_profile.is_truck')
is_truck1 = serializers.NullBooleanField(
source='customer_profile.is_truck')
class Meta:
model = User
fields = ('id', 'username', 'password', 'is_truck', 'is_truck1')
def create(self, validated_data):
user = User.objects.create_user(**validated_data)
return user
class UpdateDriveFileAccountSerializer(serializers.ModelSerializer):
account_uid = serializers.UUIDField(required=True)
title = serializers.CharField(max_length=100, required=False)
output_agol = serializers.NullBooleanField(required=False)
output_database = serializers.NullBooleanField(required=False)
output_kml = serializers.NullBooleanField(required=False)
header_row_index = serializers.IntegerField(required=False)
x_column_index = serializers.IntegerField(required=False)
y_column_index = serializers.IntegerField(required=False)
date_column_index = serializers.IntegerField(required=False)
grid_zone_column_index = serializers.IntegerField(required=False)
class Meta:
model = DriveFileAccount
fields = [
"account_uid",
"title",
"header_row_index",
"sheet_ids",
"x_column_index",
"y_column_index",
"grid_zone_column_index",
"date_column_index",
"output_agol",
"output_database",
"output_kml",
]
def validate_sheet_ids(self, sheet_ids):
try:
js_value = json.loads(sheet_ids)
if not isinstance(js_value, list):
raise serializers.ValidationError(
"invalid sheet_ids, must be JSON formatted list")
except json.JSONDecodeError:
raise serializers.ValidationError(
"invalid sheet_ids, must be JSON formatted")
return sheet_ids
def validate(self, attrs):
unknown = set(self.initial_data) - set(self.fields)
if unknown:
raise serializers.ValidationError("Unknown field(s): {}".format(
", ".join(unknown)))
return attrs
class DetailsSerializer(serializers.Serializer):
_id = serializers.CharField()
is_error = serializers.NullBooleanField()
is_valid = serializers.NullBooleanField()
is_tracked = serializers.NullBooleanField()
address = serializers.IPAddressField()
reputation_val = serializers.IntegerField()
activities = serializers.ListField()
first_activity = serializers.IntegerField()
last_activity = serializers.IntegerField()
activity_types = serializers.ListField()
city = serializers.CharField()
country = serializers.CharField()
organization = serializers.CharField()
latitude = serializers.FloatField()
class UpdateRtAccountSerializer(serializers.Serializer):
account_uid = serializers.UUIDField(required=True)
title = serializers.CharField(max_length=100, required=False)
output_agol = serializers.NullBooleanField(required=False)
output_kml = serializers.NullBooleanField(required=False)
def validate(self, attrs):
unknown = set(self.initial_data) - set(self.fields)
if unknown:
raise serializers.ValidationError("Unknown field(s): {}".format(
", ".join(unknown)))
return attrs
class TaskValuesSerializer(serializers.Serializer):
product_input_not_required = serializers.NullBooleanField(required=False)
product_input = serializers.CharField()
product_input_amount = serializers.FloatField()
product_input_measure = serializers.CharField()
labware_not_required = serializers.NullBooleanField()
labware_identifier = serializers.CharField(required=False, allow_null=True)
labware_amount = serializers.IntegerField(required=False)
labware_barcode = serializers.CharField(required=False, allow_null=True)
equipment_choice = serializers.CharField(required=False, allow_null=True)
input_fields = InputFieldValueSerializer(many=True)
variable_fields = VariableFieldValueSerializer(many=True)
calculation_fields = CalculationFieldValueSerializer(many=True)
output_fields = OutputFieldValueSerializer(many=True)
step_fields = StepFieldValueSerializer(many=True)
class OSBSSerializer(StrictSerializerMixin, serializers.ModelSerializer):
component = component_serializers.ReleaseComponentField(read_only=True)
autorebuild = serializers.NullBooleanField()
class Meta:
model = models.OSBSRecord
fields = ('component', 'autorebuild')
class DateSummarySerializer(serializers.Serializer):
"""
Serializer for Date Summary Objects.
"""
complete = serializers.NullBooleanField()
date = serializers.DateTimeField()
date_type = serializers.CharField()
description = serializers.CharField()
learner_has_access = serializers.SerializerMethodField()
link = serializers.SerializerMethodField()
link_text = serializers.CharField()
title = serializers.CharField()
def get_learner_has_access(self, block):
learner_is_full_access = self.context.get('learner_is_full_access',
False)
block_is_verified = (getattr(block, 'contains_gated_content', False)
or isinstance(block, VerificationDeadlineDate))
return (not block_is_verified) or learner_is_full_access
def get_link(self, block):
if block.link:
request = self.context.get('request')
return request.build_absolute_uri(block.link)
return ''
class UpdateAncmReqSerilizer(serializers.Serializer):
content = serializers.CharField(min_length=0,
max_length=1000,
required=False,
allow_blank=True,
help_text=u"通知内容")
type = serializers.CharField(min_length=0,
max_length=15,
required=False,
allow_blank=True,
help_text=u"通知类型")
active = serializers.NullBooleanField(required=False, help_text=u"通知是否启用")
title = serializers.CharField(min_length=0,
max_length=64,
required=False,
allow_blank=True,
help_text=u"通知标题")
level = serializers.CharField(min_length=0,
max_length=32,
required=False,
allow_blank=True,
help_text=u"通知的等级")
a_tag = serializers.CharField(min_length=0,
max_length=256,
required=False,
allow_blank=True,
help_text=u"A标签文字")
a_tag_url = serializers.CharField(min_length=0,
max_length=1024,
required=False,
allow_blank=True,
help_text=u"a标签跳转地址")
class TestNullBooleanField(FieldValues):
"""
Valid and invalid values for `BooleanField`.
"""
valid_inputs = {
'true': True,
'false': False,
'null': None,
True: True,
False: False,
None: None
}
invalid_inputs = {
'foo': ['`foo` is not a valid boolean.'],
}
outputs = {
'true': True,
'false': False,
'null': None,
True: True,
False: False,
None: None,
'other': True
}
field = serializers.NullBooleanField()
class CustomerProfileSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
is_truck = serializers.NullBooleanField(default=False),
class Meta:
model = CustomerProfile
fields = '__all__'
class EditSerializer(serializers.Serializer):
EditID = serializers.IntegerField(source='id', required=False, read_only=True)
RecordID = serializers.CharField(required=False)
RecordType = serializers.CharField(required=False)
EditType = serializers.CharField(required=False)
ParentID = serializers.CharField(required=False)
ParentRecordType = serializers.CharField(required=False)
PreviousValue = serializers.CharField(required=False, read_only=True)
FieldName = serializers.CharField(required=False)
Value = serializers.CharField(required=False, allow_blank=True)
IsConfirmed = serializers.NullBooleanField(required=False, read_only=True)
ConfirmingUserID = UserSerializer(source='get_user_confirm', required=False, read_only=True)
ModifyingUserID = UserSerializer(source='get_user_modify', required=False, read_only=True)
ModifiedDate = serializers.DateTimeField(required=False, read_only=True)
VoteRating = serializers.IntegerField(required=False, read_only=True)
def __init__(self, *args, **kwargs):
called_by_view = kwargs.pop('called_by_view', False)
hide_ui_fields = kwargs.pop('hide_ui_fields', True)
super(EditSerializer, self).__init__(*args, **kwargs)
if called_by_view is True and hide_ui_fields is True:
excluded_field_names = ['EditID', 'RecordID', 'RecordType', 'EditType', 'ParentID', 'ParentRecordType',
'PreviousValue', 'FieldName', 'IsConfirmed', 'ConfirmingUserID', 'ModifyingUserID',
'ModifiedDate', 'VoteRating']
for field in excluded_field_names:
self.fields.pop(field)
def update(self, instance, validated_data):
pass
def create(self, validated_data):
pass
class LoginSerializer(serializers.Serializer):
email = serializers.EmailField(max_length=255)
username = serializers.CharField(max_length=255, read_only=True)
password = serializers.CharField(max_length=128, write_only=True)
token = serializers.CharField(max_length=255, read_only=True)
is_create_new_password = serializers.NullBooleanField(required=False)
role = serializers.IntegerField(required=False)
def validate(self, data):
email = data.get('email', None)
password = data.get('password', None)
if email is None:
raise serializers.ValidationError(
'An email address is required to log in.')
if password is None:
raise serializers.ValidationError(
'A password is required to log in.')
user_obj = User.objects.filter(email=email, is_active=True).first()
user = authenticate(username=email, password=password)
if user is None:
raise serializers.ValidationError(
'A user with this email and password was not found.')
if not user.is_active:
raise serializers.ValidationError(
'This user has been deactivated.')
return {
'email': user.email,
'role': user.role,
'is_create_new_password': user.is_create_new_password,
'token': user.token,
}
class StatusSerializer(serializers.ModelSerializer):
is_static = serializers.NullBooleanField(required=False)
station = PollingStationSerializer(required=False, read_only=True)
class Meta:
model = Status
fields = ('id', 'name', 'type', 'is_static', 'options', 'station')
options = OptionSerializer(many=True)
def create(self, validated_data):
options = validated_data.pop('options')
status = Status.objects.create(**validated_data)
for option in options:
Option.objects.create(status=status, **option)
return status
def update(self, instance, validated_data):
options = validated_data.pop('options')
instance.name = validated_data["name"]
instance.type = validated_data["type"]
instance.is_static = validated_data.get("is_static", None)
if validated_data.get("is_static", None) and instance.stations:
instance.stations.clear()
Option.objects.filter(status=instance).delete()
for option in options:
Option.objects.create(status=instance, **option)
instance.save()
return instance
class BidSerializer(serializers.Serializer):
id = serializers.IntegerField(read_only=True)
bidder = serializers.PrimaryKeyRelatedField(
read_only=True, default=serializers.CurrentUserDefault())
price = serializers.DecimalField(max_digits=12, decimal_places=2)
lot = serializers.PrimaryKeyRelatedField(read_only=True)
accepted = serializers.NullBooleanField()
class ImageUploadSerializer(serializers.ModelSerializer):
user = serializers.PrimaryKeyRelatedField(
read_only=True, default=serializers.CurrentUserDefault())
hash = serializers.PrimaryKeyRelatedField(read_only=True)
w = serializers.IntegerField()
h = serializers.IntegerField()
uploader_in_progress = serializers.NullBooleanField()
def get_key_value_tags(self, image):
return '\n'.join([
"%s=%s" % (x.key, x.value)
for x in KeyValueTag.objects.filter(image=image)
])
class Meta:
model = Image
fields = (
'user',
'pk',
'hash',
'title',
'image_file',
'is_wip',
'skip_notifications',
'w',
'h',
'uploader_in_progress',
)
class UserRegistrationSerializer(serializers.Serializer):
email = serializers.EmailField(
validators=[UniqueValidator(User.objects.all())], required=False)
is_agree_with_agreement = serializers.NullBooleanField()
password1 = serializers.CharField()
password2 = serializers.CharField()
def validate_password2(self, value):
validate_password(value)
return value
def validate(self, attrs):
if attrs['password1'] != attrs['password2']:
raise ValidationError(detail=_('Passwords does not match'))
return super().validate(attrs)
def create(self, validated_data):
username = validated_data.get(User.USERNAME_FIELD)
is_agree_with_agreement = validated_data.get('is_agree_with_agreement')
user = User.objects.create(
username=username,
email=validated_data.get('email'),
is_agree_with_agreement=timezone.now()
if is_agree_with_agreement else None,
)
user.set_password(validated_data.get('password2'))
user.save()
return user
class AParamSerializer(serializers.ModelSerializer):
class Meta:
fields = base_fields
model = AParam
mandatory = serializers.NullBooleanField(source='required')
short_description = serializers.CharField(source='help_text')
type = serializers.SerializerMethodField(source='param_type')
when = RecursiveField(many=True,
read_only=True,
source='dependents_inputs')
@staticmethod
def get_type(param):
if param.type == ParamType.TYPE_LIST:
return "select"
elif param.type == ParamType.TYPE_DECIMAL:
return "float"
elif param.type == ParamType.TYPE_INT:
return "number"
return param.type
def to_representation(self, instance):
repr_initial = super(AParamSerializer,
self).to_representation(instance)
if instance.dependents_inputs.count() == 0:
repr_initial.pop('dependents_inputs', None)
repr_initial.pop('when', None)
if instance.when_value is not None:
reprs = {instance.when_value: repr_initial}
return reprs
return repr_initial
class WebPrizePieceForm(PieceForm):
prize_name = serializers.CharField(max_length=100, required=True)
num_editions = serializers.IntegerField(required=False,
default=None,
allow_null=True,
read_only=True)
terms = serializers.NullBooleanField(write_only=True)
extra_data = serializers.SerializerMethodField()
def get_extra_data(self, obj):
return _parse_extra_data(self.context.get('request', None))
def validate_terms(self, value):
if not value:
raise serializers.ValidationError(
"You must agree to the terms of service in order to submit a piece."
)
return value
class Meta(PieceForm.Meta):
fields = PieceForm.Meta.fields + ('prize_name', 'extra_data', 'terms')
def validate_prize_name(self, value):
prize = _validate_prize(value, self.context["request"].user)
if len(
PrizePiece.objects.filter(prize=prize,
user=self.context["request"].user)
) >= prize.num_submissions:
raise serializers.ValidationError(
'You already submitted {} works to the {} prize'.format(
prize.num_submissions, prize.name))
return prize
