class CommentSerializer(ModelSerializer): upvoters_count = IntegerField(read_only=True) label = CharField(source='user.get_label', read_only=True) full_name = CharField(source='user.full_name', read_only=True) username = CharField(source='user.username', read_only=True) upvoted = BooleanField(read_only=True) image = ProfileImageSerializer(source='user.image', read_only=True) user_id = IntegerField(read_only=True, source='user.id') class Meta: model = Comment fields = ('description', 'id', 'user', 'post', 'created_at', 'updated_at', 'upvoters_count', 'label', 'full_name', 'upvoted', 'image', 'username', 'user_id') extra_kwargs = { 'user': { 'read_only': True }, 'post': { 'read_only': True } } def create(self, validated_data): comment = Comment(**dict(validated_data, user=self.context['user'])) comment.save() return comment
class QuestionSerializer(ModelSerializer): options = OptionSerializer(many=True) isMultipleCorrect = BooleanField() class Meta: model = Question fields = '__all__'
class SourceOptionsSerializer(NotEmptySerializer): """Serializer for the SourceOptions model.""" ssl_protocol = ValidStringChoiceField( required=False, choices=SourceOptions.SSL_PROTOCOL_CHOICES) ssl_cert_verify = BooleanField(allow_null=True, required=False) disable_ssl = BooleanField(allow_null=True, required=False) use_paramiko = BooleanField(allow_null=True, required=False) class Meta: """Metadata for serializer.""" model = SourceOptions fields = [ 'ssl_protocol', 'ssl_cert_verify', 'disable_ssl', 'use_paramiko' ]
class OfficerAllegationXlsxSerializer(Serializer): # from allegation crid = CharField(source='allegation.crid') officer_name = CharField(allow_blank=True, source='officer.full_name') address = CharField(allow_blank=True, source='allegation.address') old_complaint_address = CharField( allow_null=True, source='allegation.old_complaint_address') incident_date = DateTimeField(format='%Y-%m-%d', allow_null=True, source='allegation.incident_date', default_timezone=pytz.utc) is_officer_complaint = BooleanField( source='allegation.is_officer_complaint') beat = CharField(source='allegation.beat.name', allow_null=True) coaccused_count = IntegerField(allow_null=True, source='allegation.coaccused_count') category = CharField(allow_null=True) subcategory = CharField(allow_null=True) start_date = DateField(allow_null=True) end_date = DateField(allow_null=True) recc_finding = CharField(allow_blank=True, source='recc_finding_display') recc_outcome = CharField(allow_blank=True) final_finding = CharField(allow_blank=True, source='final_finding_display') final_outcome = CharField(allow_blank=True) disciplined = NullBooleanField()
class OrganizationAdminSerializer(Serializer): id = IntegerField(allow_null=True, required=False) name = CharField(max_length=100) primary_address = CharField(max_length=255) primary_contact_name = CharField(max_length=255) primary_contact_email = CharField(max_length=255) primary_contact_phone = CharField(max_length=255) mode_of_contact = CharField(required=False, allow_null=True, allow_blank=True, max_length=255) program_count = IntegerField(allow_null=True, required=False) user_count = IntegerField(allow_null=True, required=False) is_active = BooleanField() class Meta: fields = ( 'id', 'name', 'primary_address', 'primary_contact_name', 'primary_contact_email', 'primary_contact_phone', 'mode_of_contact', 'program_count', 'user_count', 'is_active', )
class ContainerReadinessSerializer(Serializer): parent_container_slug = CharField(allow_blank=True, allow_null=True, required=False) container_slug = CharField(required=True) ready_to_publish = BooleanField(required=True) def run_validation(self, data=empty): init = super().run_validation(data) if not init: return init if not data.get("parent_container_slug", ""): init.pop("parent_container_slug", "") return init def save(self, **kwargs): if not self.validated_data: self.is_valid(True) versioned = self.instance.load_version() container = search_container_or_404(versioned, self.validated_data) container.ready_to_publish = self.validated_data["ready_to_publish"] sha = versioned.repo_update( versioned.title, versioned.get_introduction(), versioned.get_conclusion(), commit_message=_("{} est {} à la publication.").format( container.get_path(True), _("prêt") if container.ready_to_publish else _("ignoré"), ), ) PublishableContent.objects.filter(pk=self.instance.pk).update( sha_draft=sha) def to_representation(self, instance): return {}
class ReqSingleContract(Serializer): market = CharField(required=True) transaction_type = ChoiceField(required=True, choices=[0, 1]) allow_market_order = BooleanField(required=False, default=None) price = FloatField(required=False, default=None) volume = FloatField(required=False, default=None)
class DisableOptionalProductsOptionsSerializer(NotEmptySerializer): """The extended production search options of a scan.""" jboss_eap = BooleanField(required=False) jboss_fuse = BooleanField(required=False) jboss_brms = BooleanField(required=False) jboss_ws = BooleanField(required=False) class Meta: """Metadata for serializer.""" model = DisabledOptionalProductsOptions fields = ['jboss_eap', 'jboss_fuse', 'jboss_brms', 'jboss_ws']
class ContactSerializer(ModelSerializer): forest_internal_id = CharField(read_only=True) forest_id = UUIDField(read_only=True) forestcustomer_id = UUIDField(read_only=True) customer_id = UUIDField(read_only=True) owner_customer_id = UUIDField(read_only=True) cc_attrs = JSONField(read_only=True) # forest customer contact default default = BooleanField(read_only=True) is_basic = BooleanField(read_only=True) forests_count = IntegerField(read_only=True) business_id = CharField(read_only=True) class Meta: model = Contact exclude = ["contact_info", "deleted"]
class GameSerializer(ModelSerializer): players = PlayerInGameSerializer(many=True) update_last_active = BooleanField(required=False, default=False) class Meta: model = Game fields = [ 'id', 'name', 'owner', 'serialized_game', 'view_of_game', 'state', 'version', 'players', 'update_last_active' ] def update(self, instance, validated_data): instance.version = validated_data.pop('version', instance.version) instance.serialized_game = validated_data.pop('serialized_game', instance.serialized_game) instance.view_of_game = validated_data.pop('view_of_game', instance.view_of_game) instance.state = validated_data.pop('state', instance.state) if validated_data.pop('update_last_active', False): instance.last_active_at = django.utils.timezone.now() instance.players.all().delete() players_data = validated_data.pop('players') for player_data in players_data: PlayerInGame.objects.create(game=instance, **player_data) instance.save() return instance
class PayAwardResponseSerializer(HyperlinkedModelSerializer): payment_successful = BooleanField() failure_message = CharField(max_length=255, default="") class Meta: model = PayAwardResult fields = ['payment_successful', 'failure_message']
class UserSerializer(ModelSerializer): is_deputy = BooleanField(read_only=True) class Meta: model = User fields = ('id', 'username', 'first_name', 'last_name', 'email', 'is_staff', 'is_deputy', 'handle')
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): """User Serializer""" is_superuser = BooleanField(read_only=True) avatar = CharField(read_only=True) attributes = JSONField(validators=[is_dict], required=False) groups = ListSerializer(child=GroupSerializer(), read_only=True, source="ak_groups") uid = CharField(read_only=True) class Meta: model = User fields = [ "pk", "username", "name", "is_active", "last_login", "is_superuser", "groups", "email", "avatar", "attributes", "uid", ]
class PriceCurrencySerializer(ModelSerializer): resource_uri = HyperlinkedIdentityField(view_name='price-currency-detail') tier = HyperlinkedRelatedField(view_name='price-tier-detail') currency = ChoiceField(choices=ALL_CURRENCIES.items()) carrier = SlugChoiceField(choices_dict=CARRIER_MAP, required=False, empty=None) price = DecimalField() provider = EnumeratedField(PROVIDER_CHOICES) method = EnumeratedField(PAYMENT_METHOD_CHOICES) region = SlugChoiceField(choices_dict=dict(REGIONS_CHOICES_SLUG)) paid = BooleanField() dev = BooleanField() class Meta: model = PriceCurrency fields = ['carrier', 'currency', 'dev', 'method', 'paid', 'price', 'provider', 'region', 'resource_uri', 'tier']
class UserDialogChangeSerializer(ModelSerializer): user = UUIDRemouteRelatedField(queryset=UserRelationModel.objects.all(), return_uid=True) admin = BooleanField(default=False, required=False) class Meta: model = UserDialog fields = ['user', 'admin']
class VerifyMessageResponseSerializer(HyperlinkedModelSerializer): memo = CharField(max_length=settings.MAX_MEMO_SIZE) identity_pubkey = CharField(max_length=255) valid = BooleanField() class Meta: model = VerifyMessageResult fields = ['memo', 'valid', 'identity_pubkey']
class ChangePrivateAccountStatusSerializer(Serializer): is_private_account = BooleanField(required=True, error_messages={ 'required': 'is_private_account key is required', 'blank': 'Is private account is required' })
class SongStoresSerializer(Serializer): ''' A serializer for adding or removing a data store from a song based on the song's id number. ''' # TODO: Probably should move to PrimaryKeyRelatedField. store = IntegerField() set_active = BooleanField(default=False)
class UserAdminReportSerializer(ModelSerializer): id = IntegerField(allow_null=True, required=False) organization_name = CharField(source="organization.name", max_length=255, allow_null=True, allow_blank=True, required=False) organization_id = IntegerField(source="organization.id") user_programs = IntegerField(required=False) is_active = BooleanField(source="user.is_active") is_admin = BooleanField(source="user.is_staff", required=False) is_super = BooleanField(source="user.is_superuser", required=False) class Meta: model = TolaUser fields = ('id', 'name', 'organization_name', 'organization_id', 'user_programs', 'is_active', 'is_admin', 'is_super')
class IssuerSerializer(ModelSerializer): has_logo = BooleanField(source="get_has_logo", read_only=True) class Meta: model = Issuer exclude = ( "logo_b64", )
class RegisterSerializer(Serializer): """Serializer for registering devices.""" update = None create = None registered = BooleanField(read_only=True) verbose_name = CharField(read_only=True)
class DebRemoteSerializer(RemoteSerializer): """ A Serializer for DebRemote. """ distributions = CharField( help_text='Whitespace separated list of distributions to sync', required=True, ) components = CharField( help_text='Whitespace separatet list of components to sync', required=False, ) architectures = CharField( help_text='Whitespace separated list of architectures to sync', required=False, ) sync_sources = BooleanField( help_text='Sync source packages', required=False, ) sync_udebs = BooleanField( help_text='Sync installer packages', required=False, ) sync_installer = BooleanField( help_text='Sync installer files', required=False, ) class Meta: fields = RemoteSerializer.Meta.fields + ( 'distributions', 'components', 'architectures', 'sync_sources', 'sync_udebs', 'sync_installer', ) model = DebRemote
class AccountSerializer(ModelSerializer): balance = MoneyField(default=Money('0.00', 'EUR'), read_only=True) avatar = ImageField(read_only=True) locked = BooleanField(read_only=True, source='is_locked') class Meta: model = mete_models.Account fields = ['avatar', 'balance', 'locked', 'created_at', 'updated_at']
def update(self, request, *args, **kwargs): instance = self.get_object() active = None if 'active' in request.data: active = BooleanField().to_representation(request.data['active']) if (('active' in request.data) and active != instance.active): Activity.objects.filter(post=instance).update(active=active) return super(AdminPostDetailView, self).update(request, *args, **kwargs)
class CustomsData(Serializer): aes = CharField(required=False, allow_blank=True, allow_null=True) eel_pfc = CharField(required=False, allow_blank=True, allow_null=True) content_type = ChoiceField(required=False, choices=CUSTOMS_CONTENT_TYPE, allow_blank=True, allow_null=True) content_description = CharField(required=False, allow_blank=True, allow_null=True) incoterm = ChoiceField(required=False, allow_null=True, choices=INCOTERMS, help_text="The customs 'term of trade' also known as 'incoterm'") commodities = Commodity(many=True, required=False, allow_null=True, help_text="The parcel content items") duty = Payment(required=False, allow_null=True, help_text=""" The payment details.<br/> Note that this is required for a Dutiable parcel shipped internationally. """) invoice = CharField(required=False, allow_null=True, allow_blank=True, help_text="The invoice reference number") commercial_invoice = BooleanField(required=False, allow_null=True, help_text="Indicates if the shipment is commercial") certify = BooleanField(required=False, allow_null=True, help_text="Indicate that signer certified confirmed all") signer = CharField(required=False, allow_blank=True, allow_null=True) certificate_number = CharField(required=False, allow_blank=True, allow_null=True) options = PlainDictField(required=False, allow_null=True)
class UpdateRegistrySerializer(BasicSerializer): def update(self, instance, validated_data): instance.harvest_rate = validated_data.get('harvest_rate', instance.harvest_rate) instance.harvest = validated_data.get('harvest', instance.harvest) return oai_registry_api.upsert(instance) harvest_rate = IntegerField(required=True) harvest = BooleanField(required=True)
class ComicReaderSettingsSerializer(Serializer): """Reader settings the user can change.""" fitTo = ChoiceField( # noqa: N815 choices=FIT_TO_CHOICES, allow_null=True, required=False, ) twoPages = BooleanField(allow_null=True, required=False) # noqa: N815
class AudioListSerializer(ModelSerializer): name = CharField(max_length=255, required=False) artist = ArtistSerializer(required=False) extra_sm_image_thumbnail = ImageField(read_only=True) has_lyrics = BooleanField(read_only=True) class Meta: model = Audio fields = ['id', 'name', 'length', 'has_lyrics', 'slug', 'bitrate', 'audio_file', 'artist', 'extra_sm_image_thumbnail']
class LikePostSerilizer(Serializer): post_id = CharField(error_messages={ 'required': 'post_id key is required', 'blank': 'post_id is required' }) is_liked = BooleanField(error_messages={ 'required': 'is_liked key is required', 'blank': 'is_liked is required' })