class PFBModelSerializer(serializers.ModelSerializer):
"""Base serializer for PFBModel
This base serializer should be used for any serializer that needs
to serialize a model that inherites from ``PFBModel``. It automatically
handles setting ``created_by`` and ``modified_by``
"""
def __init__(self, *args, **kwargs):
super(PFBModelSerializer, self).__init__(*args, **kwargs)
self.request = self.context.get('request')
uuid = serializers.UUIDField(read_only=True)
createdAt = serializers.DateTimeField(default=CreateOnlyDefault(now),
read_only=True,
source='created_at')
modifiedAt = serializers.DateTimeField(default=now,
read_only=True,
source='modified_at')
createdBy = serializers.HiddenField(default=CreateOnlyDefault(
CurrentUserDefault()),
source='created_by')
modifiedBy = serializers.HiddenField(default=CurrentUserDefault(),
source='modified_by')
class Meta:
model = PFBModel
class CategoriesSerializer(serializers.ModelSerializer):
created_by = serializers.HiddenField(default=CurrentUserDefault())
modified_by = serializers.HiddenField(default=CurrentUserDefault())
class Meta:
model = Categories
fields = [
'id', 'created_on', 'modified_on', 'created_by', 'modified_by',
'name', 'description', 'image', 'is_live'
]
class ProductsSerializer(serializers.ModelSerializer):
created_by = serializers.HiddenField(default=CurrentUserDefault())
modified_by = serializers.HiddenField(default=CurrentUserDefault())
class Meta:
model = Product
fields = [
'id', 'created_on', 'modified_on', 'created_by', 'modified_by',
'name', 'description', 'price', 'image', 'is_live', 'category',
'is_featured'
]
def update(self):
my_kiln_user_profile = KilnModels.KilnUserProfile.objects.get(
user=CurrentUserDefault())
my_kiln_user_profile.temperature_display_units = self.validated_data[
"kiln_user_profile_id"]
my_kiln_user_profile.kiln = self.validated_data["kiln"]
my_kiln_user_profile.save()
class ReviewSerializer(serializers.ModelSerializer):
author = serializers.SlugRelatedField(
slug_field='username',
read_only=True,
default=CurrentUserDefault(),
)
title = serializers.SlugRelatedField(
slug_field='name',
read_only=True,
)
def validate(self, data):
if self.context['request'].method != 'POST':
return data
title_id = self.context['view'].kwargs['title_id']
user = self.context['request'].user
if Review.objects.filter(title=title_id, author=user).exists():
raise serializers.ValidationError('Error double', code=400)
return data
class Meta:
model = Review
fields = (
'id',
'text',
'title',
'author',
'score',
'pub_date',
)
class VersionSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = Version
fields = ['id', 'version', 'name', 'creator']
class InvoiceSerializer(NestedModelSerializer,
ContentTypeAnnotatedModelSerializer):
created_by = SimplestUserSerializer(required=False,
read_only=True,
default=CreateOnlyCurrentUserDefault())
updated_by = SimplestUserSerializer(required=False,
read_only=True,
default=CurrentUserDefault())
project = NestedProjectSerializer()
user = SimplestUserSerializer()
full_title = serializers.CharField(read_only=True)
milestone = SimpleProgressEventSerializer(required=False, allow_null=True)
tax_amount = serializers.DecimalField(max_digits=17,
decimal_places=2,
read_only=True)
subtotal = serializers.DecimalField(max_digits=17,
decimal_places=2,
read_only=True)
total_amount = serializers.DecimalField(max_digits=17,
decimal_places=2,
read_only=True)
download_url = serializers.CharField(read_only=True)
due_at = serializers.DateTimeField(read_only=True)
is_overdue = serializers.BooleanField(read_only=True)
class Meta:
model = Invoice
fields = '__all__'
class ReviewSerializer(serializers.ModelSerializer):
user = UserSerializer(default=CurrentUserDefault())
class Meta:
model = Review
fields = '__all__'
def to_representation(self, instance):
self.fields['product'] = ProductSerializer(read_only=True)
self.fields['user'] = UserSerializer(read_only=True)
return super(ReviewSerializer, self).to_representation(instance)
def create(self, validated_data):
validated_data['user'] = self.context["request"].user
return super().create(validated_data)
def validate(self, data):
if self.instance is None:
if Review.objects.filter(user=self.context["request"].user).filter(
product=data['product'].id).count() >= 1:
raise ValidationError('Нельзя')
else:
pass
return data
class ShopCartSerializer(serializers.Serializer):
user = serializers.HiddenField(default=CurrentUserDefault())
goods = serializers.PrimaryKeyRelatedField(required=True, queryset=Goods.objects.all())
nums = serializers.IntegerField(required=True, min_value=1, error_messages={
'required': '商品数量必须添加',
'min_value': '商品数量不能少于1'
})
def create(self, validated_data):
# goods: this.productId, // 商品id nums: this.buyNum, // 购买数量
goods = validated_data['goods']
nums = validated_data['nums']
user = self.context['request'].user
# 进行数据库的查询
shopcart = ShoppingCart.objects.filter(user=user, goods=goods)
if shopcart.exists():
# 原来在购物车中存在此商品
cart = shopcart.first()
cart.nums += nums
cart.save()
else:
# 购物车中此用户没有添加过此商品
cart = ShoppingCart.objects.create(user=user, goods=goods, nums=nums)
return cart
def update(self, instance, validated_data):
# instance shopcart对象
instance.nums = validated_data['nums']
instance.save()
return instance
class CartSerializer(serializers.ModelSerializer):
created_by = serializers.HiddenField(default=CurrentUserDefault())
product = ProductsCartSerializer(read_only=True, many=True)
class Meta:
model = Categories
fields = ['id', 'modified_on', 'created_by', 'product']
class SubscriptionSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
class Meta:
fields = ('author', 'user')
model = Subscription
validators = (validate_author, )
class PostCreateSerializer(serializers.ModelSerializer):
author = serializers.PrimaryKeyRelatedField(read_only=True, default=CurrentUserDefault())
def to_representation(self, instance):
"""
Object instance -> Dict of primitive datatypes.
"""
ret = OrderedDict()
fields = self._readable_fields
for field in fields:
try:
attribute = field.get_attribute(instance)
except SkipField:
continue
# KEY IS HERE:
if attribute in [None, '']:
continue
check_for_none = attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
if check_for_none is None:
ret[field.field_name] = None
else:
ret[field.field_name] = field.to_representation(attribute)
return ret
class Meta:
model = Post
fields = ('text', 'author', 'channel', 'media')
class CreateTestRunSerializer(CreatePublicTestRunSerializer):
owner = HiddenField(default=CurrentUserDefault())
class Meta(CreatePublicTestRunSerializer.Meta):
fields = list(CreatePublicTestRunSerializer.Meta.fields) + [
'owner', 'is_public'
]
class WordSerializer(serializers.HyperlinkedModelSerializer):
url = serializers.HyperlinkedIdentityField(view_name="api:word-detail")
version = serializers.PrimaryKeyRelatedField(
queryset=WordVersion.objects.all(), )
submitter = serializers.PrimaryKeyRelatedField(
default=CurrentUserDefault(),
read_only=True,
)
class Meta:
model = Word
fields = (
'url',
'word',
'ipa',
'creation_date',
'wiktionary_link',
'version',
'status',
'submitter',
)
def create(self, validated_data):
submitter = validated_data['submitter'].profile
validated_data['submitter'] = submitter
return Word.objects.create(**validated_data)
class ImageSerializer(ModelSerializer):
user = serializers.PrimaryKeyRelatedField(read_only=True,
default=CurrentUserDefault())
class Meta:
model = Image
fields = ["id", "user", "image", "name", "color"]
extra_kwargs = {
"image": {
"required": False
},
"name": {
"required": True
},
"color": {
"required": True
},
}
def create(self, validated_data):
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
image_instance = Image(**validated_data)
image_instance.user = user
image_instance.save()
return image_instance
def update(self, instance, validated_data):
instance.name = validated_data["name"]
instance.color = validated_data["color"]
instance.save()
return instance
class UserDeleteSerializer(Serializer):
# most of this is actually redundant, i don't need to have a validation step, but i do this
# out of paranoia reasons that someone may delete their account by mistake
password = CharField()
user = HiddenField(default=CurrentUserDefault())
uuid = UUIDField()
def validate(self, data):
user = data["user"]
validated_password = check_password(data["password"], user.password)
if not validated_password:
raise ValidationError("Invalid Password Entered")
validated_uuid = str(user.uuid) == str(data["uuid"])
if not validated_uuid:
raise ValidationError("Invalid UUID", str(user.uuid))
validate_user = user.username != "*****@*****.**"
if not validate_user:
raise ValidationError(
f"This is a protected user and cannot be deleted. {user.username}"
)
return data
class DeckSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=CurrentUserDefault())
kanji_list = serializers.ReadOnlyField()
class Meta:
model = Deck
fields = '__all__'
class OrderSerializer(serializers.ModelSerializer):
user = UserSerializer(default=CurrentUserDefault())
summary = serializers.HiddenField(default=0)
status = serializers.CharField(default="NEW")
position = OrderProductSerializer(many=True, source='order_product')
class Meta:
model = Order
fields = '__all__'
def to_representation(self, instance):
self.fields['summary'] = serializers.IntegerField()
self.fields['user'] = UserSerializer(read_only=True)
return super(OrderSerializer, self).to_representation(instance)
def create(self, validated_data):
order_product = validated_data.pop("order_product")
order = Order.objects.create(**validated_data)
summary = 0
if "position" in self.initial_data:
positions = self.initial_data.get("position")
for pos in positions:
id = pos.get("Product")
amount = pos.get("amount")
product_instance = Product.objects.get(pk=id)
product_price = product_instance.price
summary += amount * product_price
OrderProduct(Order=order,
Product=product_instance,
amount=amount).save()
order.summary = summary
order.save()
return order
class AreaOfInterestSerializer(GeoFeatureModelSerializer):
changesets_url = SerializerMethodField()
user = HiddenField(default=CurrentUserDefault())
geometry = GeometryField(read_only=True)
class Meta:
model = AreaOfInterest
geo_field = 'geometry'
fields = [
'id', 'name', 'filters', 'geometry', 'date', 'changesets_url',
'user'
]
validators = [
UniqueTogetherValidator(queryset=AreaOfInterest.objects.all(),
fields=('name', 'user'))
]
def get_changesets_url(self, obj):
return reverse('supervise:aoi-list-changesets', args=[obj.id])
def validate(self, data):
if data.get('filters') is None and data.get('geometry') is None:
raise ValidationError(
'Set a value to the filters field or to the geometry to be able to save the AoI'
)
return data
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 AnnotationSerializer(ModelSerializer):
organization = OrganizationSerializer(read_only=True)
platform = PlatformSerializer(read_only=True)
subject = ReadOnlyField()
organization_id = PrimaryKeyRelatedField(
source='organization',
write_only=True,
allow_null=True,
queryset=Organization.objects.all())
platform_id = PrimaryKeyRelatedField(source='platform',
write_only=True,
allow_null=True,
queryset=Platform.objects.all())
can_edit = BooleanField(read_only=True)
submitter = HiddenField(default=CurrentUserDefault())
class Meta:
model = Annotation
fields = ('pk', 'organization_id', 'platform_id', 'subject',
'subject_en', 'subject_cs', 'short_message',
'short_message_en', 'short_message_cs', 'message',
'message_en', 'message_cs', 'start_date', 'end_date',
'organization', 'platform', 'level', 'can_edit', 'submitter')
extra_kwargs = {
'subject_en': {
'allow_blank': False
},
'subject_cs': {
'allow_blank': False
},
}
def update(self, instance: Annotation, validated_data):
# in patch updates, the submitter field might not be present
submitter = validated_data.pop('submitter',
None) or self.context['request'].user
if not instance.can_edit(submitter):
raise PermissionDenied(
'User is not allowed to edit this object - it is locked.')
result = super().update(instance, validated_data) # type: Annotation
return self._adjust_permissions(result, submitter)
def create(self, validated_data):
submitter = validated_data.pop('submitter') # type: User
result = super().create(validated_data)
return self._adjust_permissions(result, submitter)
@classmethod
def _adjust_permissions(cls, instance: Annotation, submitter: User):
instance.author = submitter
instance.owner_level = submitter.organization_relationship(instance.organization_id) \
if instance.organization_id else UL_CONS_STAFF
# 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()
instance.can_edit = instance.can_edit(submitter)
return instance
class DoctorFileUploadSerializer(DoctorFileSerializer):
uploader = serializers.HiddenField(default=CurrentUserDefault())
prescription = CurrentUserPrimaryKeyRelatedField(
queryset=Prescription.objects.select_all(), required=True)
file = serializers.FileField(write_only=True)
class Meta(DoctorFileSerializer.Meta):
fields = DoctorFileSerializer.Meta.fields
class ProductVersionSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
model = ProductVersion
# 逆参照のrelated_name=vulnerabilityをfieldsに入れる
fields = ['id', 'name', 'version', 'creator', 'created_at', 'vulnerability']
class PatientFileUploadSerializer(PatientFileSerializer):
uploader = serializers.HiddenField(default=CurrentUserDefault())
file_prescription = CurrentUserPrimaryKeyRelatedField(
queryset=FilePrescription.objects.select_all(), required=True)
file = serializers.FileField(use_url=False)
class Meta(PatientFileSerializer.Meta):
fields = PatientFileSerializer.Meta.fields + ['file']
class PostSerializer(serializers.ModelSerializer):
owner = OwnerSerializer(
default=CurrentUserDefault(), read_only=True, required=False
)
class Meta:
model = Post
fields = ("id", "post_image", "caption", "owner", "likes_count", "created_at")
read_only_fields = ("id",)
class ProductSerializer(serializers.ModelSerializer):
creator = serializers.HiddenField(default=serializers.CreateOnlyDefault(CurrentUserDefault()))
class Meta:
# 対象のモデル
model = Product
# 利用するフィールド
fields = ['id', 'name', 'part', 'vendor', 'url', 'creator']
class UserFavSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=CurrentUserDefault())
class Meta:
model = UserFav
fields = ('id', 'user', 'goods')
validators = [
UniqueTogetherValidator(queryset=UserFav.objects.all(), fields=('user', 'goods'), message='商品已收藏')
]
class CommentSerializer(serializers.ModelSerializer):
author = serializers.SlugRelatedField(slug_field='username',
queryset=User.objects.all(),
default=CurrentUserDefault())
class Meta:
model = Comment
fields = '__all__'
read_only_fields = ['review', 'author']
class SushiCredentialsSerializer(ModelSerializer):
organization = OrganizationSerializer(read_only=True)
platform = PlatformSerializer(read_only=True)
active_counter_reports_long = \
CounterReportTypeSerializer(many=True, source='active_counter_reports', read_only=True)
organization_id = PrimaryKeyRelatedField(
source='organization',
write_only=True,
queryset=Organization.objects.all())
platform_id = PrimaryKeyRelatedField(source='platform',
write_only=True,
queryset=Platform.objects.all())
locked_for_me = BooleanField(read_only=True)
can_lock = BooleanField(read_only=True)
submitter = HiddenField(default=CurrentUserDefault())
locked = SerializerMethodField()
class Meta:
model = SushiCredentials
fields = ('pk', 'organization', 'platform', 'enabled', 'url',
'counter_version', 'requestor_id', 'customer_id',
'http_username', 'http_password', 'api_key', 'extra_params',
'active_counter_reports', 'active_counter_reports_long',
'organization_id', 'platform_id', 'submitter',
'locked_for_me', 'lock_level', 'can_lock', 'locked',
'outside_consortium')
def get_locked(self, obj: SushiCredentials):
return obj.lock_level >= UL_CONS_STAFF
def update(self, instance: SushiCredentials, validated_data):
submitter = validated_data.pop('submitter',
None) or self.context['request'].user
if not instance.can_edit(submitter):
raise PermissionDenied(
'User is not allowed to edit this object - it is locked.')
result = super().update(instance,
validated_data) # type: SushiCredentials
result.last_updated_by = submitter
result.save()
submitter_level = submitter.organization_relationship(
result.organization_id)
result.can_lock = submitter_level >= UL_CONS_STAFF
result.locked_for_me = submitter_level < result.lock_level
return result
def create(self, validated_data):
submitter = validated_data.pop('submitter')
result = super().create(validated_data)
result.last_updated_by = submitter
result.save()
submitter_level = submitter.organization_relationship(
result.organization_id)
result.can_lock = submitter_level >= UL_CONS_STAFF
result.locked_for_me = submitter_level < result.lock_level
return result
class PaperBookmarkSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=CurrentUserDefault())
delete_url = serializers.SerializerMethodField()
class Meta:
model = PaperBookmark
fields = ['user', 'to_object', 'delete_url']
def get_delete_url(self, obj):
return reverse('api:v1:paperbookmark-detail', args=[obj.id])