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'
})
