class FilterDataSerializer(serializers.ModelSerializer):
data_type = fields.ChoiceField(choices=file_choice_field, required=True)
country = serializers.IntegerField(required=True, allow_null=False)
start_date = serializers.DateField(required=True,
input_formats=["%Y-%m-%d"])
end_date = serializers.DateField(required=True, input_formats=["%Y-%m-%d"])
search_field = fields.ChoiceField(choices=search_choice_field,
required=True)
search_value = serializers.ListField(required=True)
class Meta:
model = FilterDataModel
fields = ('data_type', 'country', 'start_date', 'end_date',
'search_field', 'search_value')
def get_query_serializer_class(self,
exclude=(),
disallow=(),
implicit_expand=True):
"""Generate serializer to either validate request querystring or
generate documentation."""
attrs = {
k: (
ImplicitExpandableListField
if implicit_expand else fields.ListField
)(
required=False,
help_text=(
"Query parameter to expand nested fields. "
"Can be provided multiple times to expand multiple fields. "
"Field is automatically expanded whenever it is updated."),
child=fields.ChoiceField(
required=False,
choices=[i.path for i in v if i.path not in disallow]),
)
for k, v in groupby(self._get_all_expandable_fields(
parents=[], this=self, exclude=exclude),
key=lambda i: i.query_key)
}
attrs["implicit_expand"] = implicit_expand
return type("ExpandableQuerySerializer", (serializers.Serializer, ),
attrs)
class LocationSerializer(serializers.MongoEngineModelSerializer):
type = fields.ChoiceField(source='type', choices=Location.TYPE_CHOICES)
class Meta:
model = Location
exclude = ('created_at', )
class EventSerializer(serializers.ModelSerializer):
club = ClubSerializer(required=False)
state = fields.ChoiceField(choices=EVENT_STATE_LIST, default="created")
last_edited_by = serializers.CharField(
default=serializers.CurrentUserDefault())
def validate_audience(self, value):
key_list = set(row[0] for row in AUDIENCE_LIST)
val_list = set(value.split(","))
if not val_list.issubset(key_list):
raise serializers.ValidationError("Invalid audience!")
return value
def update(self, instance, validated_data):
instance.last_edited_by = self.context["request"].user.username
instance.name = validated_data.get("name")
instance.datetime = validated_data.get("datetime")
instance.audience = validated_data.get("audience")
instance.venue = validated_data.get("venue")
instance.creator = validated_data.get("creator")
instance.state = validated_data.get("state")
instance.duration = validated_data.get("duration")
instance.save()
return instance
class Meta:
model = Event
fields = "__all__"
class VehicleSerializer(ModelSerializer):
name = fields.ChoiceField(choices=['a', 'b'])
class Meta:
model = Vehicle
session = session
fields = '__all__'
class DisasterSerializer(serializers.MongoEngineModelSerializer):
status = fields.ChoiceField(source='status',
choices=Disaster.DISASTER_STATUS)
class Meta:
model = Disaster
depth = 4
exclude = ('created_at', )
class MovePageAPIActionSerializer(Serializer):
destination_page_id = fields.IntegerField(required=True)
position = fields.ChoiceField(required=False,
choices=[
'left', 'right', 'first-child',
'last-child', 'first-sibling',
'last-sibling'
])
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 NotificationSettingsSerializer(WritableNestedModelSerializer):
ranges = NotificationTimeRangeSerializer(many=True)
ranges_mode = fields.ChoiceField(NotificationSettings.MODE_CHOICES)
class Meta:
model = NotificationSettings
fields = ('pk', 'user', 'enable_push', 'enable_mail',
'notify_interval', 'ranges', 'ranges_mode')
read_only_fields = ('user', )
class CSVDisasterSerializer(serializers.MongoEngineModelSerializer):
name = serialiserzz.Field(source='csv_name')
status = fields.ChoiceField(source='status',
choices=Disaster.DISASTER_STATUS)
location = serialiserzz.Field(source='csv_locations', label='Locations')
class Meta:
model = Disaster
depth = 4
exclude = ('id', 'created_at', 'locations')
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 MovePageAPIActionSerializer(Serializer):
destination_page_id = fields.IntegerField(required=True)
position = fields.ChoiceField(
required=False,
choices=[
"left",
"right",
"first-child",
"last-child",
"first-sibling",
"last-sibling",
],
)
class ExportImportUploadSerializer(serializers.Serializer):
file = serializers.FileField(required=True)
type_of_sheet = fields.ChoiceField(choices=file_choice_field,
required=True)
country_id = serializers.IntegerField(required=True, allow_null=False)
def validate_country_id(self, country_id):
if not CountryMaster.objects.filter(id=country_id):
raise serializers.ValidationError("Invalid Country id")
return country_id
class Meta:
fields = ('file', 'type_of_sheet', ' country_id')
class TicketsCreateSerializer(serializers.Serializer):
STATUS_CHOICES = (
('ABIERTO', 'Abierto'),
('PENDIENTE', 'Pendiente'),
('EN PROCESO', 'En proceso'),
('RESUELTO', 'Resuelto'),
('CERRADO', 'Cerrado'),
)
title = fields.CharField(max_length=255, required=False)
description = fields.CharField(required=False)
status = fields.ChoiceField(choices=STATUS_CHOICES,
required=False,
default='ABIERTO')
class NewsletterSerializer(serializers.Serializer):
NEWSLETTER_CHOICES_API = {
# string passed to the API : actual string passed to basket.
'about:apps': 'mozilla-and-you,marketplace-desktop',
'marketplace': 'marketplace'
}
email = fields.EmailField()
newsletter = fields.ChoiceField(required=False,
default='marketplace',
choices=NEWSLETTER_CHOICES_API.items())
def transform_newsletter(self, obj, value):
# Transform from the string the API receives to the one we need to pass
# to basket.
default = self.fields['newsletter'].default
return self.NEWSLETTER_CHOICES_API.get(value, default)
class SearchRequestSerializer(serializers.Serializer):
keywords = fields.CharField(default=None)
namespaces = SeparatedStringField(
child=fields.RegexField(regex=constants.NAME_REGEXP),
default=None,
)
names = SeparatedStringField(
child=fields.RegexField(regex=constants.NAME_REGEXP),
default=None,
)
tags = SeparatedStringField(default=None, )
contributor_type = fields.ChoiceField(
choices=constants.NS_TYPES,
default=None,
)
platforms = SeparatedStringField(default=None)
cloud_platforms = SeparatedStringField(default=None)
deprecated = fields.NullBooleanField(default=None)
class BaseExporterOptionsSerializer(serializers.Serializer):
view_id = fields.IntegerField(
min_value=0,
required=False,
allow_null=True,
help_text=
"Optional: The view for this table to export using its filters, "
"sorts and other view specific settings.",
)
exporter_type = fields.ChoiceField(
choices=lazy(table_exporter_registry.get_types, list)(),
help_text="The file type to export to.",
)
# Map to the python encoding aliases at the same time by using a DisplayChoiceField
export_charset = DisplayChoiceField(
choices=SUPPORTED_EXPORT_CHARSETS,
default="utf-8",
help_text="The character set to use when creating the export file.",
)
class PublicationSerializer(serializers.ModelSerializer):
type = fields.ChoiceField(choices=PUBLICATION_TYPES._doubles)
documents = NestedDocumentSerializer(many=True, required=False)
class Meta:
model = Publication
extra_kwargs = {'id': {'read_only': True}}
exclude = ('submitted_by', )
def create(self, validated_data):
docs_data = validated_data.pop('documents', [])
user = self.context['request'].user
if user.is_anonymous:
user = None
data = validated_data.copy()
data['submitted_by'] = user
try:
publication = super().create(data)
except IntegrityError as e:
# err... this is silly but oh well
err = str(e)
msg = "Integrity Error"
# WARNING: this is based on a very specific error format
# and is quite likely to fail on upgrade
if err.startswith(
"duplicate key value violates unique constraint"):
detail = err.splitlines()[1]
_intro = 'DETAIL:'
if detail.startswith(_intro):
detail = detail[len(_intro):].strip()
msg += ": " + detail
raise serializers.ValidationError(msg)
for doc_data in docs_data:
doc_data['submitted_by'] = user
Document.objects.create(publication=publication, **doc_data)
return publication
class Meta:
param_fields = (
('username',
fields.CharField(
label=_('login name'),
max_length=64,
help_text=_(
'Help text for field. It will show in api document'))),
('password', fields.CharField(label=_('password'))),
('gender',
fields.ChoiceField(label=_('gender'),
choices=constants.Gender.get_choices_list())),
('mobile', fields.RegexField(r'1\d{10}',
label=_('mobile number'))),
('nickname', fields.CharField(label=_('nick name'),
max_length=255)),
('name',
fields.CharField(label=_('name'), default='', max_length=255)),
('avatar', fields.ImageField(label=_('avatar'), default=None)),
)
class CommentSerializer(serializers.ModelSerializer):
rate = fields.ChoiceField(source='note', choices=models.Comment._meta.get_field('note').choices)
author = CommentAuthorField()
def full_clean(self, instance):
instance = super(CommentSerializer, self).full_clean(instance)
if instance and instance.booking:
if instance.type == COMMENT_TYPE_CHOICES.OWNER \
and instance.booking.owner.has_pro_subscription:
self._errors.update({
'author': _(u'Only borrowers can comment professional bookings')
})
return None
return instance
class Meta:
model = models.Comment
fields = ('id', 'booking', 'comment', 'rate', 'created_at', 'author') # 'author' must follow after the 'booking'
public_fields = ('id', 'booking', 'comment', 'rate', 'created_at', 'author')
read_only_fields = ('created_at',)
immutable_fields = ('booking', 'author')
class NewsletterSerializer(serializers.Serializer):
NEWSLETTER_CHOICES_API = {
# string passed to the API : actual string passed to basket.
'about:apps': 'mozilla-and-you,marketplace-desktop',
'marketplace-firefoxos': 'marketplace',
'marketplace-desktop': 'mozilla-and-you',
'marketplace-android': 'mozilla-and-you'
}
email = fields.EmailField()
newsletter = fields.ChoiceField(default='marketplace-firefoxos',
required=False,
choices=NEWSLETTER_CHOICES_API.items())
lang = fields.CharField()
def to_representation(self, obj):
"""Transform from the string the API receives to the one we need to
pass to basket."""
data = super(NewsletterSerializer, self).to_representation(obj)
default = self.fields['newsletter'].default
data['newsletter'] = self.NEWSLETTER_CHOICES_API.get(
obj['newsletter'], default)
return data
class DataPacifierSerializer(serializers.Serializer):
type = fields.ChoiceField(choices=("AF", "HL"), default="AF")
position = geo_fields.PointField(str_points=True)
amount = fields.IntegerField(max_value=20, min_value=1, default=1)
target = fields.ChoiceField(choices=("staging", "production", "local"))
authKey = fields.CharField()
