class TeamListSerializer(serializers.ModelSerializer):
leader = TeammateSerializer(
default=CreateOnlyDefault(CurrentUserDefault()))
tags = serializers.PrimaryKeyRelatedField(many=True,
queryset=Tag.objects.all(),
pk_field=serializers.CharField(),
required=False)
likes = TeammateSerializer(read_only=True, many=True)
image = serializers.ImageField(required=False, use_url=True)
parent_comments = serializers.SerializerMethodField()
comments_count = serializers.SerializerMethodField()
class Meta:
model = Team
fields = [
'id', 'tags', 'likes', 'like_count', 'leader', 'title', 'end_date',
'description', 'image', 'max_personnel', 'current_personnel',
'comments_count', 'parent_comments', 'created_at', 'updated_at'
]
def get_parent_comments(self, obj):
parent_comments = obj.comments.filter(parent=None)
serializer = CommentSerializer(parent_comments, many=True)
return serializer.data
def get_comments_count(self, obj):
return obj.comments.count()
class CustomFieldModelSerializer(ValidatedModelSerializer):
"""
Extends ModelSerializer to render any CustomFields and their values associated with an object.
"""
computed_fields = SerializerMethodField(read_only=True)
custom_fields = CustomFieldsDataField(
source="_custom_field_data",
default=CreateOnlyDefault(CustomFieldDefaultValues()),
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.instance is not None:
# Retrieve the set of CustomFields which apply to this type of object
content_type = ContentType.objects.get_for_model(self.Meta.model)
fields = CustomField.objects.filter(content_types=content_type)
# Populate CustomFieldValues for each instance from database
if type(self.instance) in (list, tuple):
for obj in self.instance:
self._populate_custom_fields(obj, fields)
else:
self._populate_custom_fields(self.instance, fields)
def _populate_custom_fields(self, instance, custom_fields):
instance.custom_fields = {}
for field in custom_fields:
instance.custom_fields[field.name] = instance.cf.get(field.name)
def get_computed_fields(self, obj):
return obj.get_computed_fields()
class Meta:
model = RevenueGroup
fields = '__all__'
# CreateOnlyDefault will be provided on object creation if they're not provided by FE side
extra_kwargs = {
'revenue_from': {
'default':
CreateOnlyDefault(lambda: Revenue.objects.aggregate(min=Min(
'revenue'))['min']),
},
'revenue_to': {
'default':
CreateOnlyDefault(lambda: Revenue.objects.aggregate(max=Max(
'revenue'))['max']),
},
}
class ChildCommentSerializer(serializers.ModelSerializer):
author = TeammateSerializer(
default=CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = Comment
fields = [
'id', 'parent', 'team', 'author', 'body', 'created_at',
'updated_at'
]
class ApplicationSerializer(serializers.ModelSerializer):
applicant = UserSerializer(default=CreateOnlyDefault(CurrentUserDefault()))
application_status = serializers.SerializerMethodField()
class Meta:
model = Application
fields = ('id', 'team', 'applicant', 'reason', 'github_account',
'created_at', 'updated_at', 'application_status')
read_only_fields = ('applicant', )
validators = [
UniqueTogetherValidator(queryset=Application.objects.all(),
fields=['team', 'applicant'])
]
def get_application_status(self, application):
return application.get_status_display()
class BuyItemPriceSerializer(serializers.ModelSerializer):
class Meta:
model = BuyItemPrice
read_only_fields = ("bar",)
_type = VirtualField("BuyItemPrice")
bar = serializers.PrimaryKeyRelatedField(read_only=True, default=CurrentBarCreateOnlyDefault())
barcode = serializers.CharField(required=False, write_only=True)
buyitem = serializers.PrimaryKeyRelatedField(required=False, default=CreateOnlyDefault(None), queryset=BuyItem.objects.all())
price = serializers.FloatField(required=False)
def validate_price(self, price):
if price is not None and price < 0:
raise ValidationError("Price must be positive")
return price
def validate(self, data):
if data.get('barcode') is not None:
if data.get('buyitem') is None:
try:
data['buyitem'] = BuyItem.objects.get(barcode=data['barcode'])
except BuyItem.DoesNotExist:
raise Http404('Barcode does not exist')
if 'barcode' in data:
data.pop('barcode')
return data
def create(self, data):
if data.get('buyitem') is None and data.get('barcode') is None:
raise ValidationError("Specify a barcode or a buyitem")
buyitemprice = super(BuyItemPriceSerializer, self).create(data)
bar = buyitemprice.bar
buyitem = buyitemprice.buyitem
if "price" not in data:
other_prices = BuyItemPrice.objects.filter(bar=bar, buyitem__details=buyitem.details).exclude(pk=buyitemprice.pk)
if other_prices.count() != 0:
price = sum([bip.price / bip.buyitem.itemqty for bip in other_prices.all()]) / other_prices.count()
buyitemprice.price = price * buyitem.itemqty
buyitemprice.save()
return buyitemprice
class ResellerPublicKeySerializer(serializers.ModelSerializer):
created_at = serializers.DateTimeField(read_only=True,
default=CreateOnlyDefault(
timezone.now))
user = UserMinSerializer(read_only=True,
default=serializers.CurrentUserDefault())
class Meta:
model = PublicKey
fields = ('id', 'name', 'public_key', 'created_at', 'fingerprint',
'user')
read_only_fields = (
'id',
'fingerprint',
'user',
)
validators = [
UniqueTogetherValidator(
queryset=PublicKey.objects.all(),
fields=('name', 'user'),
message=_('A key already exists with the same name'))
]
def to_internal_value(self, data):
data = super().to_internal_value(data)
data['fingerprint'] = get_fingerprint(data['public_key'])
return data
@staticmethod
def validate_public_key(value):
if not is_valid_ssh_public_key(value):
raise serializers.ValidationError(_('Invalid SSH public key'))
return value
@staticmethod
def validate_name(value):
# NOTE(tomo): OpenStack only allows "_- " digits and numbers
safechars = "_- " + string.digits + string.ascii_letters
clean_value = "".join(x for x in value if x in safechars)
if clean_value != value:
raise serializers.ValidationError(
_("Name contains unsafe characters"))
return value
class ApplicationSerializer(serializers.ModelSerializer):
applicant = UserSerializer(default=CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = Application
fields = (
'id',
'team',
'applicant',
'reason',
'github_account',
'created_at',
'updated_at',
)
read_only_fields = ('applicant', )
validators = [
UniqueTogetherValidator(queryset=Application.objects.all(),
fields=['team', 'applicant'])
]
class CustomFieldModelSerializer(ValidatedModelSerializer):
"""
Extends ModelSerializer to render any CustomFields and their values associated with an object.
"""
custom_fields = CustomFieldsSerializer(required=False,
default=CreateOnlyDefault(
CustomFieldDefaultValues()))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.instance is not None:
# Retrieve the set of CustomFields which apply to this type of object
content_type = ContentType.objects.get_for_model(self.Meta.model)
fields = CustomField.objects.filter(obj_type=content_type)
# Populate CustomFieldValues for each instance from database
try:
for obj in self.instance:
self._populate_custom_fields(obj, fields)
except TypeError:
self._populate_custom_fields(self.instance, fields)
def _populate_custom_fields(self, instance, custom_fields):
instance.custom_fields = {}
for field in custom_fields:
value = instance.cf.get(field.name)
if field.type == CustomFieldTypeChoices.TYPE_SELECT and type(
value) is CustomFieldChoice:
instance.custom_fields[
field.name] = CustomFieldChoiceSerializer(value).data
else:
instance.custom_fields[field.name] = value
def _save_custom_fields(self, instance, custom_fields):
content_type = ContentType.objects.get_for_model(self.Meta.model)
for field_name, value in custom_fields.items():
custom_field = CustomField.objects.get(name=field_name)
CustomFieldValue.objects.update_or_create(
field=custom_field,
obj_type=content_type,
obj_id=instance.pk,
defaults={
'serialized_value': custom_field.serialize_value(value)
},
)
def create(self, validated_data):
with transaction.atomic():
instance = super().create(validated_data)
# Save custom fields
custom_fields = validated_data.get('custom_fields')
if custom_fields is not None:
self._save_custom_fields(instance, custom_fields)
instance.custom_fields = custom_fields
return instance
def update(self, instance, validated_data):
with transaction.atomic():
custom_fields = validated_data.get('custom_fields')
instance._cf = custom_fields
instance = super().update(instance, validated_data)
# Save custom fields
if custom_fields is not None:
self._save_custom_fields(instance, custom_fields)
instance.custom_fields = custom_fields
return instance