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])