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