class MedicoCreateSerializer(ModelSerializer):
apellido = CharField(max_length=50, style={'placeholder': 'Ej: Robles'})
nombre = CharField(max_length=50, style={'placeholder': 'Ej: Miguel'})
email = EmailField(style={'placeholder': 'Ej: [email protected]'})
estado = ReadOnlyField(source='get_estado_display')
usuario = HiddenField(default=None)
generador = HiddenField(default=CurrentUserDefault())
class Meta:
model = Medico
fields = [
'dni', 'matricula', 'apellido', 'nombre', 'email', 'estado',
'telefono', 'usuario', 'generador'
]
extra_kwargs = {
'dni': {
'style': {
'placeholder': 'Ej: 12345678',
'autofocus': True
}
},
'matricula': {
'label': u'Matrícula',
'min_value': 0,
'style': {
'placeholder': 'Ej: 123456'
}
},
'telefono': {
'label': u'Teléfono',
'style': {
'placeholder': 'Ej: 11 1234 5678'
}
}
}
def create(self, validated_data):
user_obj = User(username=validated_data['matricula'],
first_name=validated_data['nombre'],
last_name=validated_data['apellido'],
email=validated_data['email'])
user_obj.set_password(validated_data['matricula'])
user_obj.save()
user_obj.groups.add(Group.objects.get(name=MEDICO['group_name']))
Medico.objects.create(dni=validated_data['dni'],
matricula=validated_data['matricula'],
telefono=validated_data['telefono'],
usuario=user_obj,
generador=validated_data['generador'])
return validated_data
class StationSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta:
model = Station
fields = (
'id',
'name',
'created',
'updated',
'type',
'notes',
'is_in_test_mode',
'altitude',
'position',
'country',
'state',
'county',
'community',
'city',
'district',
'owner',
'project',
'last_metering',
)
class EventSerializer(ModelSerializer):
"""Serializer for Event object."""
user = HiddenField(default=None)
paymaster = ParticipantNestedSerializer(required=False)
url = HyperlinkedIdentityField(view_name="events-detail")
participants_url = HyperlinkedIdentityField(view_name="participants-list",
lookup_url_kwarg="event_pk")
bills_url = HyperlinkedIdentityField(view_name="bills-list",
lookup_url_kwarg="event_pk")
payments_url = HyperlinkedIdentityField(view_name="payments-list",
lookup_url_kwarg="event_pk")
class Meta:
model = Event
fields = "__all__"
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["user"].default = self.context["request"].user
def create(self, validated_data):
paymaster_data = None
if "paymaster" in validated_data:
paymaster_data = validated_data.pop("paymaster")
event = Event.objects.create(**validated_data)
if paymaster_data:
event.paymaster = Participant.objects.create(event=event,
**paymaster_data)
event.save()
return event
class SimpleDatasetSerializer(DynamicFieldsModelSerializer):
id = HiddenField(default=None)
url = HyperlinkedIdentityField(view_name='datasets:dataset-detail')
publisher = HyperlinkedRelatedField(
view_name='publishers:publisher-detail',
read_only=True)
type = SerializerMethodField()
class Meta:
model = Dataset
fields = (
'id',
'iati_id',
'type',
'url',
'name',
'title',
'filetype',
'publisher',
'source_url',
'iati_version',
'added_manually',
)
def get_type(self, obj):
return obj.get_filetype_display()
class ProjectSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta:
model = Project
fields = ('name', 'slug', 'created', 'updated', 'website',
'description', 'logo', 'owner')
class CheckSerializer(HyperlinkedModelSerializer):
url = CheckHyperlinkedIdentityField('api-check-detail')
patch = HiddenField(default=CurrentPatchDefault())
user = UserSerializer(read_only=True, default=CurrentUserDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
data['state'] = val
break
return super(CheckSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(CheckSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
return data
class Meta:
model = Check
fields = ('id', 'url', 'patch', 'user', 'date', 'state', 'target_url',
'context', 'description')
read_only_fields = ('date', )
extra_kwargs = {
'url': {
'view_name': 'api-check-detail'
},
}
class TrainingGameCreateSerializer(HyperlinkedModelSerializer):
"""
TrainingGameCreateSerializer serialize a new game adding the current user as submitter
"""
# https://www.django-rest-framework.org/api-guide/validators/#advanced-field-defaults
submitted_by = HiddenField(default=CurrentUserDefault())
class Meta:
model = TrainingGame
fields = [
"url",
"id",
"run",
"created_at",
"submitted_by",
"board_size_x",
"board_size_y",
"handicap",
"komi",
"gametype",
"rules",
"extra_metadata",
"winner",
"score",
"resigned",
"game_length",
"white_network",
"black_network",
"sgf_file",
"training_data_file",
"num_training_rows",
"kg_game_uid",
]
extra_kwargs = {
"run": {
"lookup_field": "name"
},
"white_network": {
"lookup_field": "name"
},
"black_network": {
"lookup_field": "name"
},
}
def validate(self, data):
validate_game_npzdata(data["training_data_file"], data["run"])
if not data["white_network"].training_games_enabled or not data[
"black_network"].training_games_enabled:
raise ValidationError(
"Network is no longer enabled for training games")
if data["run"].status != Run.RunStatus.ACTIVE:
raise ValidationError("Run is not active")
if not data["submitted_by"]:
raise ValidationError("Unknown user")
if not data["run"].is_allowed_username(data["submitted_by"].username):
raise ValidationError(
"Run is currently closed except for private testing")
return data
class PlacesSerializer(GeoModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
model = Places
geo_field = "coordinates"
fields = ("id", "title", "description", "coordinates", "user")
class FileSerializer(ModelSerializer):
name = CharField(max_length=300)
photo = ImageField(required=False)
is_public = BooleanField(required=False)
delete_date = DateField(required=False)
# read_only
pk = IntegerField(read_only=True)
issue_date = DateTimeField(read_only=True)
update_date = DateTimeField(read_only=True)
file_user = DictField(read_only=True, source="user_as_dict")
file_parents = ListField(read_only=True, source="parents_as_list")
file_children = ListField(read_only=True, source="children_as_list")
# A `HiddenField` does not take input from the user, or present any output
fk_user = HiddenField(default=CurrentUserDefault())
class Meta:
model = FileModel
fields = (
"pk",
"fk_parent",
"name",
"photo",
"is_public",
"issue_date",
"update_date",
"delete_date",
"file_user",
"file_parents",
"file_children",
"fk_user",
)
class UserSerializer(ModelSerializer):
is_staff = HiddenField(default=False)
class Meta:
model = User
fields = ['username', 'email', 'is_staff']
read_only_fields = ['id']
class ChecksSerializer(ModelSerializer):
user = HyperlinkedRelatedField('user-detail',
read_only=True,
default=CurrentUserDefault())
patch = HiddenField(default=CurrentPatchDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
data['state'] = val
break
return super(ChecksSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(ChecksSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
# drf-nested doesn't handle HyperlinkedModelSerializers properly,
# so we have to put the url in by hand here.
url = self.context['request'].build_absolute_uri(
reverse('api_1.0:patch-detail', args=[instance.patch.id]))
data['url'] = url + 'checks/%s/' % instance.id
data['users_url'] = data.pop('user')
return data
class Meta:
model = Check
read_only_fields = ('date', )
class CheckSerializer(HyperlinkedModelSerializer):
url = CheckHyperlinkedIdentityField('api-check-detail')
patch = HiddenField(default=CurrentPatchDefault())
user = UserSerializer(default=CurrentUserDefault())
def run_validation(self, data):
for val, label in Check.STATE_CHOICES:
if label == data['state']:
# NOTE(stephenfin): 'data' is essentially 'request.POST', which
# is immutable by default. However, there's no good reason for
# this to be this way [1], so temporarily unset that mutability
# to fix what we need to here.
#
# [1] http://stackoverflow.com/a/12619745/613428
mutable = data._mutable # noqa
data._mutable = True # noqa
data['state'] = val
data._mutable = mutable # noqa
break
return super(CheckSerializer, self).run_validation(data)
def to_representation(self, instance):
data = super(CheckSerializer, self).to_representation(instance)
data['state'] = instance.get_state_display()
return data
class Meta:
model = Check
fields = ('id', 'url', 'patch', 'user', 'date', 'state', 'target_url',
'context', 'description')
read_only_fields = ('date',)
extra_kwargs = {
'url': {'view_name': 'api-check-detail'},
}
class TweetSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
fields = (
'id', 'tweet_content', 'writed_at', 'user', 'status') # detay ve listelemelerde gözükecek property'ler
model = Tweet
def validate(self, attrs):
if len(attrs['tweet_content']) > 150:
raise ValidationError("Tweet content very long")
elif len(attrs['tweet_content']) < 3:
raise ValidationError("Tweet content very short")
return attrs
def create(self, validated_data):
tweet = Tweet.objects.create(**validated_data)
tweet.save()
return tweet
def update(self, instance, validated_data):
# kwargs["user"] = self.fields["user"].get_default()
instance.tweet_content = validated_data.get('tweet_content', instance.tweet_content)
instance.status = validated_data.get('status', instance.status)
instance.save()
return instance
class ManualDataUploadSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
import_batch = ImportBatchSerializer(read_only=True)
can_edit = BooleanField(read_only=True)
class Meta:
model = ManualDataUpload
fields = ('pk', 'report_type', 'organization', 'platform', 'data_file',
'user', 'created', 'is_processed', 'log', 'import_batch',
'extra', 'can_edit', 'owner_level')
def validate(self, attrs):
attrs = super().validate(attrs)
return attrs
def update(self, instance: ManualDataUpload, validated_data):
result = super().update(instance, validated_data) # type: Annotation
return self._adjust_permissions(result)
def create(self, validated_data):
result = super().create(validated_data)
return self._adjust_permissions(result)
@classmethod
def _adjust_permissions(cls, instance: ManualDataUpload):
if instance.user:
instance.owner_level = \
instance.user.organization_relationship(instance.organization_id)
# we do not want to set the level too high in order for the staff to be able to edit it
if instance.owner_level > UL_CONS_STAFF:
instance.owner_level = UL_CONS_STAFF
instance.save()
return instance
class SimplePublisherSerializer(DynamicFieldsModelSerializer):
id = HiddenField(default=None)
url = HyperlinkedIdentityField(view_name='publishers:publisher-detail')
class Meta:
model = Publisher
fields = ('id', 'url', 'publisher_iati_id', 'display_name', 'name')
class FeedSerializer(ModelSerializer):
links = FeedLinkSerializer(many=True, read_only=True)
count = SerializerMethodField()
position = IntegerField(read_only=True)
user = HiddenField(default=CurrentUserDefault())
favIcon = CharField(default='undefined', required=False)
class Meta:
model = Feed
def create(self, validated_data):
position = len(Feed.objects.filter(user=validated_data['user']))
validated_data['position'] = position
feed = super().create(validated_data)
link_serializer = LinkSerializer(data=self.initial_data)
link_serializer.is_valid()
link = link_serializer.save()
feedlink_serializer = FeedLinkSerializer(
data={
'feed': feed.pk,
'link': link,
'reg_exp': self.initial_data.get('regExp', '')
})
feedlink_serializer.is_valid()
feedlink_serializer.save()
return feed
def get_count(self, obj):
return len(Post.objects.filter(feed=obj, view=False))
class FollowSerializer(CurrentUserDefault, ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
fields = ('author', 'user')
model = Follow
validators = (validate_author, )
class EventResourceSerializer(ModelSerializer):
"""Base serializer for event related models."""
event = HiddenField(default=None)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["event"].default = self.context["view"].get_event()
class TitleSerializer(ModelSerializer):
lookup_field = "id"
read_only_fields = ['id', 'created_by']
created_by = HiddenField(default=CurrentUserDefault())
class Meta:
model = Title
fields = "__all__"
class ShowCreateSerializer(ModelSerializer):
sonarr_id = HiddenField(default='')
user = HiddenField(default='')
user_email = HiddenField(default='')
class Meta:
model = Request
fields = [
'title',
'seasons',
'release_date',
'tvdb_id',
'sonarr_id',
'poster',
'user',
'user_email',
]
class MovieCreateSerializer(ModelSerializer):
# THese fields are retrieved by the backend.
cp_id = HiddenField(default='')
user = HiddenField(default='')
user_email = HiddenField(default='')
class Meta:
model = Request
fields = [
'title',
'overview',
'release_date',
'imdb_id',
'cp_id',
'poster',
'user',
'user_email',
]
class UserSignupSerializer(ModelSerializer):
is_staff = HiddenField(default=False)
class Meta:
model = User
fields = ['username', 'email', 'password', 'is_staff']
extra_kwargs = {'password': {'write_only': True}}
def validate_password(self, password):
return make_password(password)
class DatasetSerializer(DynamicFieldsModelSerializer):
id = HiddenField(default=None)
url = HyperlinkedIdentityField(view_name='datasets:dataset-detail')
publisher = SimplePublisherSerializer()
filetype = SerializerMethodField()
activities = SerializerMethodField()
activity_count = SerializerMethodField()
notes = HyperlinkedIdentityField(view_name='datasets:dataset-notes', )
DatasetNoteSerializer(many=True, source="datasetnote_set")
internal_url = SerializerMethodField()
class Meta:
model = Dataset
fields = ('id', 'iati_id', 'url', 'name', 'title', 'filetype',
'publisher', 'source_url', 'activities', 'activity_count',
'activities_count_in_xml', 'activities_count_in_database',
'date_created', 'date_updated', 'last_found_in_registry',
'iati_version', 'sha1', 'note_count', 'notes',
'added_manually', 'is_parsed', 'export_in_progress',
'parse_in_progress', 'internal_url')
def get_filetype(self, obj):
return obj.get_filetype_display()
def get_activities(self, obj):
request = self.context.get('request')
url = request.build_absolute_uri(reverse('activities:activity-list'))
try:
request_format = self.context.get('request').query_params.get(
'format')
except AttributeError:
request_format = ''
return url + '?dataset=' + str(obj.id) + '&format={request_format}'.\
format(request_format=request_format)
def get_activity_count(self, obj):
return Activity.objects.filter(dataset=obj.id).count()
def get_internal_url(self, obj):
request = self.context.get('request')
# Get internal url from the XML file in the local static folder
internal_url = obj.get_internal_url()
url = None
if internal_url:
internal_url = urllib.parse.quote(internal_url)
complete_internal_url = request.build_absolute_uri(internal_url)
if complete_internal_url is not None:
url = complete_internal_url.replace('http:', 'https:')
return url
return None
class CoverCommentSerializer(BaseCommentListSerializer):
cover = HiddenField(default=CurrentCoverDefault())
class Meta:
model = CoverComment
fields = BaseCommentListSerializer.Meta.fields + ('cover', 'addressed')
read_only_fields = BaseCommentListSerializer.Meta.read_only_fields + (
'cover',
)
versioned_fields = BaseCommentListSerializer.Meta.versioned_fields
extra_kwargs = {'url': {'view_name': 'api-cover-comment-detail'}}
class PatchCommentSerializer(BaseCommentListSerializer):
patch = HiddenField(default=CurrentPatchDefault())
class Meta:
model = PatchComment
fields = BaseCommentListSerializer.Meta.fields + ('patch',)
read_only_fields = BaseCommentListSerializer.Meta.read_only_fields + (
'patch',
)
versioned_fields = BaseCommentListSerializer.Meta.versioned_fields
extra_kwargs = {'url': {'view_name': 'api-patch-comment-detail'}}
class PersonSerializer(ModelSerializer):
lookup_field = "slug"
kennel = KennelSerializer()
read_only_fields = ['id', 'created_by']
created_by = HiddenField(default=CurrentUserDefault())
class Meta:
model = Person
fields = [
'id', 'kennel', 'pd_kennel', 'full_name', 'web_url', 'fb_url',
'created_by'
]
read_only_fields = ['pd_kennel']
class NoteSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta:
model = Note
fields = "__all__"
extra_kwargs = {
"uid": {
"read_only": True,
},
"version": {
"read_only": True,
},
}
class KennelSerializer(ModelSerializer):
lookup_field = "slug"
url = SerializerMethodField()
read_only_fields = ['id', 'created_by']
created_by = HiddenField(default=CurrentUserDefault())
class Meta:
model = Kennel
fields = "__all__"
def get_url(self, ken):
return reverse(
"core:kennel-detail",
kwargs=dict(slug=ken.slug),
request=self.context["request"],
)
class PublisherSerializer(DynamicFieldsModelSerializer):
id = HiddenField(default=None)
url = HyperlinkedIdentityField(view_name='publishers:publisher-detail')
datasets = DatasetSerializer(
many=True,
source="dataset_set",
fields=('id', 'iati_id', 'url', 'name', 'title', 'filetype',
'source_url', 'added_manually', 'is_parsed',
'export_in_progress', 'parse_in_progress'))
activity_count = SerializerMethodField()
note_count = SerializerMethodField()
activities = SerializerMethodField()
class Meta:
model = Publisher
fields = (
'id',
'url',
'iati_id',
'publisher_iati_id',
'display_name',
'name',
'organisation',
'activities',
'activity_count',
'note_count',
'datasets',
)
def get_activities(self, obj):
request = self.context.get('request')
url = request.build_absolute_uri(reverse('activities:activity-list'))
return (url + '?reporting_organisation_identifier=' +
obj.publisher_iati_id)
def get_activity_count(self, obj):
return Activity.objects.filter(
reporting_organisations__normalized_ref=obj.publisher_iati_id
).count()
def get_note_count(self, obj):
sum_queryset = Dataset.objects.filter(publisher=obj.id).aggregate(
Sum('note_count'))
return sum_queryset.get('note_count__sum')
class QuestionSerializer(ModelSerializer):
owner = HiddenField(default=CurrentUserDefault())
choices = ChoiceSerializer(many=True)
class Meta:
model = Question
fields = [
"id", "text", "creation_date", "start_date", "end_date", "choices",
"owner"
]
def create(self, validated_data):
choices = validated_data.pop("choices")
question = Question.objects.create(**validated_data)
for choice in choices:
Choice.objects.create(question=question, **choice)
return question
def update(self, instance, validated_data):
choices = validated_data.pop("choices")
instance.text = validated_data.get("text", instance.text)
instance.start_date = validated_data.get("start_date",
instance.start_date)
instance.end_date = validated_data.get("end_date", instance.end_date)
instance.save()
keep_choices = []
for choice in choices:
if "id" in choice.keys():
if Choice.objects.filter(id=choice["id"]).exists():
c = Choice.objects.get(id=choice["id"])
c.choice_text = choice.get("choice_text", c.choice_text)
c.save()
keep_choices.append(c.id)
else:
continue
else:
c = Choice.objects.create(question=instance, **choice)
keep_choices.append(c.id)
for choice in instance.choices.all():
if choice.id not in keep_choices:
choice.delete()
return instance