class ListOrItemField(Field):
"""
A field whose values are either a value or lists of values described by the given item field.
The item field can be another field type (e.g., CharField) or a serializer.
"""
def __init__(self, child, *args, **kwargs):
super(ListOrItemField, self).__init__(*args, **kwargs)
self.item_field = child
self.list_field = ListField(child=child, *args, **kwargs)
def to_representation(self, obj):
if isinstance(obj, list):
return self.list_field.to_representation(obj)
return self.item_field.to_representation(obj)
def to_internal_value(self, data):
if isinstance(data, list):
return self.list_field.to_internal_value(data)
# Force field validation. Not necessary on the list_field since DRF calls it recursively.
self.item_field.run_validation(data)
return self.item_field.to_internal_value(data)
class CinergiResourceSerializer(ResourceSerializer):
cinergi_url = CharField()
source_name = CharField()
contact_organizations = ListField(
child=CharField()
)
contact_people = ListField(
child=CharField()
)
categories = ListField(
child=CharField()
)
begin_date = DateTimeField()
end_date = DateTimeField()
resource_type = CharField()
resource_topic_categories = ListField(
child=CharField()
)
web_resources = ListField(
child=CinergiWebResourceSerializer()
)
web_services = ListField(
child=CinergiWebServiceSerializer()
)
class ShipmentRate(RateRequest):
rates = ListField(child=RateDetails(), help_text="The list of returned ")
class GitSerializer(Serializer):
time = IntegerField(min_value=0,
required=True,
label='Time',
help_text='Point of time to run report.')
url = ChoiceField(
[],
label='Git URL',
default='https://git.openstack.org/openstack/openstack-ansible',
help_text='Please select a git url.')
filters = ListField(child=FilterSerializer(),
label='Filters',
help_text="Additional filter criteria.",
required=False)
def __init__(self, *args, **kwargs):
"""Init the serializer with updated list of git urls."""
self.fields['url'].choices = self.git_urls()
super(GitSerializer, self).__init__(*args, **kwargs)
def git_urls(self):
"""Build list of selectable git urls.
:returns: All git urls
:rtype: list
"""
q = ColumnQuery('GitUrl')
q.add_column('GitUrl', 'url', 'url')
q.orderby('url', 'ASC', label='GitUrl')
urls = []
page = 1
pagesize = 1000
page_rows = q.page(page, pagesize)
while (page_rows):
for row in page_rows:
urls.append(row['url'])
page += 1
page_rows = q.page(page, pagesize)
return urls
def validate(self, data):
"""Custom validation.
Ensure filters are acting upon a filterable model.
:param data: Data to validate
:type data: dict
:returns: Validated data
:rtype: dict
"""
model_set = set(FILTERABLE_MODELS)
filter_errors = OrderedDict()
for i, f in enumerate(data.get('filters', [])):
if f['model'] not in model_set:
filter_errors[i] = ('Model {} is not one of [{}].'.format(
f['model'], ', '.join(FILTERABLE_MODELS)))
if filter_errors:
raise ValidationError({'filters': filter_errors})
return data
def form_data(self):
"""Describes web client form associated with this serializer.
:returns: List of dict objects
:rtype: list
"""
return [{
'name': 'time',
'label': self.fields['time'].label,
'help_text': self.fields['time'].help_text,
'required': self.fields['time'].required,
'component': 'Time',
'many': False
}, {
'name': 'url',
'label': self.fields['url'].label,
'help_text': self.fields['url'].help_text,
'required': self.fields['url'].required,
'default': self.fields['url'].default,
'component': 'Select',
'choices': self.fields['url'].choices
}, {
'name': 'filters',
'label': self.fields['filters'].label,
'help_text': self.fields['filters'].help_text,
'component': 'Filter',
'many': True,
'models': FILTERABLE_MODELS
}]
class GameCreateSerializer(ModelSerializer):
"""
Special format for game creation. Primarily due to providing a way to
add multiple games at once (series of games) that are only differ by
the datetime
"""
teams = PrimaryKeyRelatedField(
many=True,
required=False,
queryset=Team.objects.all(),
)
location = LocationSerializer(validators=[])
datetime = DateTimeField(required=False)
datetimes = ListField(
child=DateTimeField(),
help_text='extra datetimes, will automatically create more games',
required=False,
write_only=True,
)
name = CharField(help_text='game name', required=False)
class Meta:
model = Game
fields = 'id', 'teams', 'name', 'datetime', 'datetimes', 'location',
def is_valid(self, *args, **kwargs):
# Work around an issue with the browsable api where empty input
# value becomes [''] for a list field
if self.initial_data.get('datetimes', None) == '':
self.initial_data._mutable = True
self.initial_data.pop('datetimes')
return super().is_valid(*args, **kwargs)
def get_fields(self, *args, **kwargs):
fields = super().get_fields(*args, **kwargs)
self_fields = self.fields
request = self.context.get('request', None)
if request:
teams = fields['teams'].child_relation
teams.queryset = request.user.managed_teams
return fields
def to_representation(self, obj):
data = super().to_representation(obj)
request = self.context.get('request', None)
if request and request.accepted_renderer.format == 'api':
data['url'] = reverse('game-detail', (obj.id, ), request=request)
return data
@atomic
def create(self, validated_data):
location_data = validated_data['location']
teams = validated_data.get('teams', [])
request = self.context.get('request', None)
datetimes = []
if 'datetime' in validated_data:
datetimes.append(validated_data['datetime'])
if 'datetimes' in validated_data:
datetimes += validated_data['datetimes']
# FIXME: move validation logic to .is_valid()
if not datetimes:
raise ValidationError(
'Must include at least one of the following fields: '
'datetime, datetimes')
if len(teams) > 2:
raise ValidationError('Please pick up to 2 teams')
location_obj, _ = Location.objects.get_or_create(
name=location_data['name'],
address=location_data['address'],
)
games = []
game_name = validated_data.get('name', '')
for i, dt in enumerate(datetimes):
name_suffix = f' ({i + 1})' if i > 0 and game_name else ''
game = Game.objects.create(
datetime=dt,
location=location_obj,
organizer=request.user,
name=game_name + name_suffix,
)
game.teams.add(*teams)
for i, team in enumerate(teams):
for player in team.players.filter(role__gt=0):
rsvp, _ = RsvpStatus.objects.get_or_create(
game=game,
player=player,
)
rsvp.team = i
if player.id == request.user.id:
rsvp.status = RsvpStatus.GOING
else:
rsvp.status = RsvpStatus.INVITED
rsvp.save()
if not teams:
RsvpStatus.objects.create(
game=game,
player=request.user,
status=RsvpStatus.GOING,
)
games.append(game)
return games[0]
class ShipmentResponse(Serializer):
messages = ListField(child=Message(),
required=False,
help_text="The list of note or warning messages")
shipment = Shipment(required=False,
help_text="The submitted shipment's summary")
class MultipleFilesUploadSerializer(Serializer):
file_uploaded = ListField(FileField())
class Meta:
fields = ['file_uploaded']
class ExamSerializer(ModelSerializer):
assignments = ListField(
child=PrimaryKeyRelatedField(read_only=False, queryset=Collection.objects.all())
)
learner_ids = ListField(
child=PrimaryKeyRelatedField(
read_only=False, queryset=FacilityUser.objects.all()
),
required=False,
)
question_sources = ListField(child=QuestionSourceSerializer(), required=False)
creator = PrimaryKeyRelatedField(
read_only=False, queryset=FacilityUser.objects.all()
)
date_archived = DateTimeTzField(allow_null=True)
date_activated = DateTimeTzField(allow_null=True)
class Meta:
model = Exam
fields = (
"id",
"title",
"question_count",
"question_sources",
"seed",
"active",
"collection",
"archive",
"date_archived",
"date_activated",
"assignments",
"creator",
"data_model_version",
"learners_see_fixed_order",
"learner_ids",
)
read_only_fields = ("data_model_version",)
def validate(self, attrs):
title = attrs.get("title")
# first condition is for creating object, second is for updating
collection = attrs.get("collection") or getattr(self.instance, "collection")
if "learner_ids" in self.initial_data and self.initial_data["learner_ids"]:
if (
len(self.initial_data["learner_ids"])
!= FacilityUser.objects.filter(
memberships__collection=collection,
id__in=self.initial_data["learner_ids"],
).count()
):
raise ValidationError(
"Some learner_ids are not members of the collection that this quiz is contained in",
code=error_constants.INVALID,
)
# if obj doesn't exist, return data
try:
obj = Exam.objects.get(title__iexact=title, collection=collection)
except Exam.DoesNotExist:
return attrs
# if we are updating object, and this `instance` is the same object, return data
if self.instance and obj.id == self.instance.id:
return attrs
else:
raise ValidationError(
"The fields title, collection must make a unique set.",
code=error_constants.UNIQUE,
)
def to_internal_value(self, data):
# Make a new OrderedDict from the input, which could be an immutable QueryDict
data = OrderedDict(data)
if "creator" not in data:
if self.context["view"].action == "create":
data["creator"] = self.context["request"].user.id
else:
# Otherwise we are just updating the exam, so allow a partial update
self.partial = True
return super(ExamSerializer, self).to_internal_value(data)
def create(self, validated_data):
collections = validated_data.pop("assignments")
learners = validated_data.pop("learner_ids", [])
new_exam = Exam.objects.create(**validated_data)
# Create all of the new ExamAssignment
for collection in collections:
self._create_exam_assignment(exam=new_exam, collection=collection)
if learners:
adhoc_group = create_adhoc_group_for_learners(new_exam.collection, learners)
self._create_exam_assignment(exam=new_exam, collection=adhoc_group)
return new_exam
def _create_exam_assignment(self, **params):
return ExamAssignment.objects.create(
assigned_by=self.context["request"].user, **params
)
def update(self, instance, validated_data): # noqa
# Update the scalar fields
instance.title = validated_data.get("title", instance.title)
instance.active = validated_data.get("active", instance.active)
instance.archive = validated_data.get("archive", instance.archive)
instance.date_activated = validated_data.get(
"date_activated", instance.date_activated
)
instance.date_archived = validated_data.get(
"date_archived", instance.date_archived
)
# Add/delete any new/removed Assignments
if "assignments" in validated_data:
collections = validated_data.pop("assignments")
current_group_ids = set(
instance.assignments.exclude(
collection__kind=ADHOCLEARNERSGROUP
).values_list("collection__id", flat=True)
)
new_group_ids = set(x.id for x in collections)
for cid in new_group_ids - current_group_ids:
collection = Collection.objects.get(id=cid)
if collection.kind != ADHOCLEARNERSGROUP:
self._create_exam_assignment(exam=instance, collection=collection)
ExamAssignment.objects.filter(
exam_id=instance.id,
collection_id__in=(current_group_ids - new_group_ids),
).exclude(collection__kind=ADHOCLEARNERSGROUP).delete()
# Update adhoc assignment
if "learner_ids" in validated_data:
self._update_learner_ids(instance, validated_data["learner_ids"])
instance.save()
return instance
def _update_learner_ids(self, instance, learners):
try:
adhoc_group_assignment = ExamAssignment.objects.select_related(
"collection"
).get(exam=instance, collection__kind=ADHOCLEARNERSGROUP)
except ExamAssignment.DoesNotExist:
adhoc_group_assignment = None
if not learners:
# Setting learner_ids to empty, so only need to do something
# if there is already an adhoc_group_assignment defined
if adhoc_group_assignment is not None:
# Adhoc group already exists delete it and the assignment
# cascade deletion should also delete the adhoc_group_assignment
adhoc_group_assignment.collection.delete()
else:
if adhoc_group_assignment is None:
# There is no adhoc group right now, so just make a new one
adhoc_group = create_adhoc_group_for_learners(
instance.collection, learners
)
self._create_exam_assignment(exam=instance, collection=adhoc_group)
else:
# There is an adhoc group, so we need to potentially update its membership
original_learner_ids = Membership.objects.filter(
collection=adhoc_group_assignment.collection
).values_list("user_id", flat=True)
original_learner_ids_set = set(original_learner_ids)
learner_ids_set = set(learner.id for learner in learners)
if original_learner_ids_set != learner_ids_set:
# Only bother to do anything if these are different
new_learner_ids = learner_ids_set - original_learner_ids_set
deleted_learner_ids = original_learner_ids_set - learner_ids_set
if deleted_learner_ids:
Membership.objects.filter(
collection=adhoc_group_assignment.collection,
user_id__in=deleted_learner_ids,
).delete()
for new_learner_id in new_learner_ids:
Membership.objects.create(
user_id=new_learner_id,
collection=adhoc_group_assignment.collection,
)
class VoteGroupSerializer(ModelSerializer):
entries = ListField(
min_length=1,
child=PrimaryKeyRelatedField(queryset=Entry.objects.filter(
compo__active=True, disqualified=False)))
def validate_entries(self, entries):
# Fail if not unique entries
ids = [entry.id for entry in entries]
if len(ids) > len(set(ids)):
raise ValidationError("Voit äänestää entryä vain kerran")
return entries
def validate(self, data):
data = super(VoteGroupSerializer, self).validate(data)
compo = data['compo']
entries = data['entries']
user = self.context['request'].user
# Make sure compo voting is open
if not compo.is_voting_open():
raise ValidationError("Kompon äänestysaika ei ole voimassa")
# Make sure user has rights to vote
try:
TicketVoteCode.objects.get(associated_to=user, event=compo.event)
except TicketVoteCode.DoesNotExist:
try:
VoteCodeRequest.objects.get(user=user,
event=compo.event,
status=1)
except VoteCodeRequest.DoesNotExist:
raise ValidationError("Äänestysoikeus puuttuu")
# Make sure entries belong to the requested compo
for entry in entries:
if entry.compo.id != compo.id:
raise ValidationError({
'entries':
["Entry '{}' ei kuulu kompoon '{}'".format(entry, compo)]
})
return data
@transaction.atomic
def create(self, validated_data):
entries = validated_data.pop('entries')
compo = validated_data['compo']
user = validated_data['user']
# Delete old entries (if any) and add new ones
group = VoteGroup.objects.filter(compo=compo, user=user).first()
if group:
group.delete_votes()
else:
group = super(VoteGroupSerializer, self).create(validated_data)
# Add new voted entries
group.create_votes(entries)
# That's that. Return the group.
return group
class Meta:
model = VoteGroup
fields = (
'compo',
'entries',
)
extra_kwargs = {
'compo': {
'required': True
},
'entries': {
'required': True
},
}
class Task1Serializer(TaskSerializerBase):
coefficient_matrix = MatrixField(child=IntegerField())
constant_terms_vector = ListField(child=IntegerField())
class FilterSerializer(Serializer):
activity = ListField(child=ChoiceField(choices=Notebook.ACTIVITY_STATUS),
required=False)
important = BooleanField(required=False)
public = BooleanField(required=False)
class WordSerializer(ModelSerializer):
meanings_list = ListField()
class Meta:
model = Word
class MultipleSearchSerializer(ModelSerializer):
search_text = ListField()
class Meta:
model = Search
fields = "__all__"
class LessonSerializerBase(LessonBasicSerializerBase):
goals = ListField(child=CharField(max_length=300))
class TrackingResponse(Serializer):
messages = ListField(child=Message(),
required=False,
help_text="The list of note or warning messages")
tracking_details = TrackingDetails(
required=False, help_text="The tracking details retrieved")
class UserSerializer(ModelSerializer):
public_email = EmailField(required=False)
national_code = CharField(required=False, max_length=20, allow_blank=True)
profile_media = IntegerField(required=False, allow_null=True)
birth_date = CharField(required=False, max_length=10, allow_blank=True)
fax = CharField(required=False, allow_blank=True)
telegram_account = CharField(required=False,
max_length=256,
allow_blank=True)
description = CharField(required=False, allow_blank=True)
web_site = ListField(child=URLField(required=False), required=False)
phone = ListField(child=CharField(max_length=23, required=False),
required=False)
mobile = ListField(child=CharField(max_length=23, required=False),
required=False)
password = CharField(max_length=255)
auth_mobile = CharField(required=False,
validators=[RegexValidator('^[0][9][0-9]{9,9}$')])
class Meta:
model = User
fields = [
'id', 'username', 'password', 'first_name', 'last_name', 'email',
'password', 'date_joined', 'web_site', 'public_email',
'national_code', 'profile_media', 'birth_date', 'fax',
'telegram_account', 'description', 'phone', 'mobile', 'auth_mobile'
]
def create(self, validated_data):
validated_data['username'] = validated_data['username'].lower()
validated_data['username'] = validated_data['username'].replace(
'.', '')
user_validated_data = self.get_user_validated_args(**validated_data)
user = User.objects.create(**user_validated_data)
user.set_password(validated_data['password'])
user.save()
profile_validated_data = self.get_profile_validated_data(
**validated_data)
profile = Profile.objects.get(profile_user=user)
# set validated data to profile object
for key in profile_validated_data:
setattr(profile, key, validated_data.get(key))
profile.save()
user_strength = StrengthStates.objects.get(strength_user=user)
# check for first & last name strength rate
if validated_data.get('first_name') is not None and validated_data.get(
'last_name') is not None:
profile.profile_strength += 5
profile.save()
user_strength.first_last_name_obtained = True
# check for profile media strength rate
if 'profile_media' in profile_validated_data:
profile.profile_strength += 10
profile.save()
user_strength.profile_media_obtained = True
user_strength.registration_obtained = True
user_strength.save()
# add user to default exchange
add_user_to_default_exchange(user)
return user
def update(self, instance, validated_data):
user = User.objects.get(pk=instance.id)
profile = Profile.objects.get(profile_user=user)
user_validated_data = self.get_user_validated_args(**validated_data)
try:
user_strength = StrengthStates.objects.get(strength_user=user)
except StrengthStates.DoesNotExist:
user_strength = StrengthStates.objects.create(strength_user=user)
# check for first name strength rate
if 'first_name' in user_validated_data and user_validated_data[
'first_name'] != '':
user.first_name = user_validated_data['first_name']
if (user.first_name is None
or user.first_name == '') and (user.last_name is not None
or user.last_name != ''):
profile.profile_strength += 5
user_strength.first_last_name_obtained = True
# check for last name strength rate
if 'last_name' in user_validated_data and user_validated_data[
'last_name'] != '':
user.last_name = user_validated_data['last_name']
if (user.last_name is None
or user.last_name == '') and (user.first_name is not None
or user.first_name != ''):
profile.profile_strength += 5
user_strength.first_last_name_obtained = True
# set validated data to user object
for key in user_validated_data:
if key != 'first_name' and key != 'last_name':
setattr(user, key, user_validated_data.get(key))
if 'password' in validated_data:
user.set_password(validated_data['password'])
user.save()
profile_validated_data = self.get_profile_validated_data(
**validated_data)
# check for profile media strength rate
if 'profile_media' in profile_validated_data and profile_validated_data['profile_media'] != '' and \
profile_validated_data['profile_media'] is not None:
profile.profile_media = profile_validated_data['profile_media']
if profile.profile_media == '' or profile.profile_media is None:
profile.profile_strength += 10
user_strength.profile_media_obtained = True
# set validated data to profile object
for key in profile_validated_data:
if key != 'profile_media':
setattr(profile, key, validated_data.get(key))
profile.save()
user_strength.save()
return user
@staticmethod
def validate_first_name(value):
if len(value) > 20:
error = {
'message': "maximum length for first name is 20 character"
}
raise ValidationError(error)
return value
@staticmethod
def validate_email(value):
if value is None:
error = {'message': "email field is required"}
raise ValidationError(error)
elif len(value) > 0:
user_count = User.objects.filter(email=value).count()
if user_count == 0:
return value
error = {'message': "email already exist"}
raise ValidationError(error)
error = {'message': "email can not be blank"}
raise ValidationError(error)
@staticmethod
def validate_last_name(value):
if len(value) > 20:
error = {'message': "maximum length for last name is 20 character"}
raise ValidationError(error)
return value
@staticmethod
def validate_username(value):
if len(value) < 5:
error = {'message': "minimum length for last name is 5 character"}
raise ValidationError(error)
if len(value) > 32:
error = {'message': "minimum length for last name is 5 character"}
raise ValidationError(error)
return value
@staticmethod
def validate_password(value):
if len(value) < 8:
error = {'message': "minimum length for password is 8 character"}
raise ValidationError(error)
return value
def get_user_validated_args(self, **kwargs):
user_kwargs = {}
if 'username' in kwargs:
user_kwargs['username'] = kwargs['username']
if 'first_name' in kwargs:
user_kwargs['first_name'] = kwargs['first_name']
if 'last_name' in kwargs:
user_kwargs['last_name'] = kwargs['last_name']
if 'email' in kwargs:
user_kwargs['email'] = kwargs['email']
return user_kwargs
def get_profile_validated_data(self, **kwargs):
profile_kwargs = {}
if 'public_email' in kwargs:
profile_kwargs['public_email'] = kwargs['public_email']
if 'national_code' in kwargs:
profile_kwargs['national_code'] = kwargs['national_code']
if 'profile_media' in kwargs:
profile_kwargs['profile_media'] = kwargs['profile_media']
if 'birth_date' in kwargs:
profile_kwargs['birth_date'] = kwargs['birth_date']
if 'fax' in kwargs:
profile_kwargs['fax'] = kwargs['fax']
if 'telegram_account' in kwargs:
profile_kwargs['telegram_account'] = kwargs['telegram_account']
if 'description' in kwargs:
profile_kwargs['description'] = kwargs['description']
if 'web_site' in kwargs:
profile_kwargs['web_site'] = kwargs['web_site']
if 'phone' in kwargs:
profile_kwargs['phone'] = kwargs['phone']
if 'mobile' in kwargs:
profile_kwargs['mobile'] = kwargs['mobile']
if 'auth_mobile' in kwargs:
profile_kwargs['auth_mobile'] = kwargs['auth_mobile']
return profile_kwargs
class FBQuickRepliesListSerializer(Serializer):
text = CharField(required=False)
quick_replies = ListField(
child=FBQuickRepliesSerializer(),
required=False,
)
class GameSerializer(ModelSerializer):
"""game serializer"""
designer_name = StringRelatedField(source="designer",
many=True,
read_only=True)
artist_name = StringRelatedField(source="artist",
many=True,
read_only=True)
game_type_name = StringRelatedField(source="game_type",
many=True,
read_only=True)
category_name = StringRelatedField(source="category",
many=True,
read_only=True)
mechanic_name = StringRelatedField(source="mechanic",
many=True,
read_only=True)
contained_in = PrimaryKeyRelatedField(many=True, read_only=True)
implemented_by = PrimaryKeyRelatedField(many=True, read_only=True)
alt_name = ListField(child=CharField(), required=False)
image_url = ListField(child=URLField(), required=False)
video_url = ListField(child=URLField(), required=False)
external_link = ListField(child=URLField(), required=False)
freebase_id = ListField(child=CharField(), required=False)
wikidata_id = ListField(child=CharField(), required=False)
wikipedia_id = ListField(child=CharField(), required=False)
dbpedia_id = ListField(child=CharField(), required=False)
luding_id = ListField(child=IntegerField(min_value=1), required=False)
spielen_id = ListField(child=CharField(), required=False)
bga_id = ListField(child=CharField(), required=False)
class Meta:
"""meta"""
model = Game
fields = "__all__"
class SLAttachmentsListSerializer(Serializer):
text = CharField(required=False)
attachments = ListField(
child=SLAttachmentsSerializer(),
required=False,
)
class ExporterToZipSerializer(BasicSerializer):
"""Serializer used for entered data validation"""
exporter_id_list = ListField(required=True)
data_id_list = ListField(required=True)
class GenericSerializer(Serializer):
time = IntegerField(
min_value=0,
required=True,
label='Time',
help_text='Point of time to run report.'
)
model = ChoiceField(
_models,
label="Model",
default='Environment',
help_text=(
"Please select an end model to pull from. You can create columns "
"from any model in the path to this model."
)
)
columns = ListField(
child=ModelPropertySerializer(),
min_length=1,
label='Columns',
help_text='Please choose each column to be listed in the report.'
)
filters = ListField(
child=FilterSerializer(),
label="Filters",
help_text="Additional filter criteria.",
required=False
)
def validate(self, data):
"""Custom validation.
Ensure that all columns are properties to models in the path
to the chosen model.
Ensure that all filters are on properties to models in the path
to the chosen model.
:param data: Data to validate
:type data: dict
"""
model_set = set([t[0] for t in registry.path(data['model'])])
model_set.add(data['model'])
column_errors = OrderedDict()
for i, c in enumerate(data.get('columns', [])):
if c['model'] not in model_set:
column_errors[i] = (
'Model {} is not in path of {}'
.format(c['model'], data['model'])
)
if column_errors:
raise ValidationError({'columns': column_errors})
filter_errors = OrderedDict()
for i, f in enumerate(data.get('filters', [])):
if f['model'] not in model_set:
filter_errors[i] = (
'Model {} not in path of {}'
.format(f['model'], data['model'])
)
if filter_errors:
raise ValidationError({'filters': filter_errors})
return data
def form_data(self):
"""Describes web client form associated with this serializer.
:returns: List of dict objects
:rtype: list
"""
return [
{
'name': 'time',
'label': self.fields['time'].label,
'help_text': self.fields['time'].help_text,
'required': self.fields['time'].required,
'component': 'Time',
'many': False
},
{
'name': 'model',
'label': self.fields['model'].label,
'help_text': self.fields['model'].help_text,
'required': self.fields['model'].required,
'default': self.fields['model'].default,
'component': 'Model'
},
{
'name': 'columns',
'label': self.fields['columns'].label,
'help_text': self.fields['columns'].help_text,
'min_length': self.fields['columns'].min_length,
'component': 'ModelProperty',
'many': True,
'watches': 'model'
},
{
'name': 'filters',
'label': self.fields['filters'].label,
'help_text': self.fields['filters'].help_text,
'component': 'Filter',
'many': True,
'watches': 'model'
}
]
class SaveDocumentListAnswerSerializer(SaveAnswerSerializer):
value = ListField(child=CharField())
class Meta(SaveAnswerSerializer.Meta):
pass
def __init__(self, child, *args, **kwargs):
super(ListOrItemField, self).__init__(*args, **kwargs)
self.item_field = child
self.list_field = ListField(child=child, *args, **kwargs)
class PlannerSerializer(Serializer):
target = ListField()
attackers = AttackerSerializer(many=True)
"name",
"description",
"assigned_users",
"deadline",
"meta",
"context",
)
class CreateWorkItemSerializer(SendEventSerializerMixin,
ContextModelSerializer):
case = serializers.GlobalIDPrimaryKeyRelatedField(
queryset=models.Case.objects)
multiple_instance_task = serializers.GlobalIDPrimaryKeyRelatedField(
queryset=models.Task.objects, source="task")
controlling_groups = ListField(child=CharField(required=False),
required=False)
addressed_groups = ListField(child=CharField(required=False),
required=False)
name = CharField(
required=False,
allow_blank=True,
help_text=models.WorkItem._meta.get_field("name").help_text,
)
description = CharField(
required=False,
allow_blank=True,
help_text=models.WorkItem._meta.get_field("description").help_text,
)
def validate_multiple_instance_task(self, task):
if not task.is_multiple_instance:
class HarvestSerializer(BasicSerializer):
metadata_formats = ListField(child=CharField(), required=False)
sets = ListField(child=CharField(), required=False)
class ErrorResponse(Serializer):
messages = ListField(child=Message(),
required=False,
help_text="The list of error messages")
class OutputSerializer(serializers.Serializer):
root = ListField()
nodes = ListField()
edges = ListField()
duration = ListField()
class StudentSerializer(ModelSerializer):
weeks = ListField()
class Meta:
model = LMSUser
fields = ('id', 'fullname', 'weeks')
class SaveDefaultListAnswerSerializer(SaveDefaultAnswerSerializer):
value = ListField(child=CharField(), required=False)
class Meta(SaveDefaultAnswerSerializer.Meta):
pass
class CourseContentPageEventSerializer(ModelSerializer):
weeks = ListField()
class Meta:
model = Page
fields = ('id', 'title', 'parent_id', 'content_type', 'weeks')
