标签: django-serializer

我有一个 APIView 提供我的模型实例。我想根据 url 参数使用不同的序列化器，因为我想根据参数提供不同的字段。我不想对所有情况都使用 if else 检查，因此我使用了一个函数，该函数根据类型键从序列化器对象 dict 提供序列化器。有好的解决办法吗？有人有更好的建议吗？另外，您在考虑使用不同的端点而不是这种方法。这是代码：

urls.py

from django.urls import path
from .views import MySerializerTestView

urlpatterns = [
    path('<slug:type>', MySerializerTestView.as_view()),
]

模型.py

from django.db import models
class MyModel(models.Model):
    field_first = models.CharField(max_length=10)
    field_second = models.CharField(max_length=10)
    field_third = models.CharField(max_length=10)

视图.py

from .models import MyModel
from rest_framework.response import Response
from rest_framework.views import APIView
from .serializers import MyFirstSerializer,MySecondSerializer,MyThirdSerializer

class MySerializerTestView(APIView):
    def get(self, request, **kwargs):
        my_data = MyModel.objects.all()
        serializer = self.get_serializer(self.kwargs['type'],my_data)
        return Response(serializer.data)


    def get_serializer(self,type,data):
        my_serializers = {
        'first':MyFirstSerializer(data,many=True),
        'second':MySecondSerializer(data,many=True),
        'third':MyThirdSerializer(data,many=True), …

我正在使用 django rest 框架在 django 中创建第一个rest api

我无法获取 json 格式的对象。序列化器始终返回空对象 {}

模型.py

class Shop(models.Model):
    shop_id = models.PositiveIntegerField(unique=True)
    name = models.CharField(max_length=1000)
    address = models.CharField(max_length=4000)

序列化器.py

class ShopSerializer(serializers.ModelSerializer):
    class Meta:
        model = Shop
        fields = '__all__'

视图.py

@api_view(['GET'])
def auth(request):
    username = request.data['username']
    password = request.data['password']
    statusCode = status.HTTP_200_OK
    try:
        user = authenticate(username=username, password=password)
        if user:
            if user.is_active:
                
                context_data = request.data
                
                shop = model_to_dict(Shop.objects.get(retailer_id = username))
                shop_serializer = ShopSerializer(data=shop)
                if shop:
                    try:
                        
                        if shop_serializer.is_valid():
                            print('is valid')
                            print(shop_serializer.data)
                            context_data = shop_serializer.data
                        else:
                            print('is …

我在一个使用 DRF 的项目中工作，我得到的序列化器数据如下，这绝对没问题：

{
    "message": "Updated Successfully",
    "status": 200,
    "errors": {},
    "data": {
        "id": 8,
        "user": 2,
        "item": 1,
        "quantity": 4,
        "created_at": "2021-08-11T13:49:27.391939Z",
        "updated_at": "2021-08-11T13:51:07.229794Z"
    }
}

但我想得到如下：

{
    "message": "Updated Successfully",
    "status": 200,
    "errors": {},
    "data": {
        "id": 8,
        "user": "user name",
        "item": "product name",
        "price: "3.44",
        "quantity": 4,
        "created_at": "2021-08-11T13:49:27.391939Z",
        "updated_at": "2021-08-11T13:51:07.229794Z"
    }
}

我尝试使用 DRF RelatedField，PrimaryKryRelatedField但在所有这些情况下，我需要创建read_only=True我想跳过的相应字段。

我也尝试过depth = 1它给出了完整的细节

我的型号：

class Cart(models.Model):
    user = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True)
    item = …

我想根据 GET 调用中获得的查询参数过滤掉一些实例。

class RevisionSerializer(serializers.ModelSerializer):
    slot_info = serializers.SerializerMethodField(required=False, read_only=True)
    batch_config = serializers.SerializerMethodField(required=False, read_only=True)

    class Meta:
        model = Revision
        fields = ['id', 'status', 'revision_id', 'instructor', 'number_of_classes', 'start_date',
                  'slot', 'slot_info', 'tinyurl', 'zoom_link', 'batch_config']
        read_only_fields = ['revision_id']

    def get_batch_config(self, obj):
        # filter this on the incoming data from the GET call
        related_batches = CompensationClass.objects.select_related('style', 'instructor').filter(
            compensation_class_id=obj.revision_id)

        batch_config_values = related_batches.values('batch_id', 'age_group', 'level', 'course_version', 'style__name',
                                                     'class_number')
        return batch_config_values

这是我的序列化器，我将传递一个日期，并根据该日期我想过滤我的序列化器方法字段。我怎样才能实现这个目标？

我想获取传递给函数中的序列化程序的id值
id = serializers.IntegerField(label='ID')以获取配置文件对象

def profile_info(self, obj)

但它给出的错误id是IntegerField请传递 int 或 string

任何人都可以告诉我如何获取在id字段中传递的值，谢谢。下面是我的序列化程序代码

class UserSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField(label='ID')
    # print ('dadddaaa ',serializers.data)
    profile = serializers.SerializerMethodField('profile_info')
    username = serializers.CharField()
    first_name = serializers.CharField()
    last_name = serializers.CharField()
    # Nazir = serializers.CharField()
    # profile = UsersSerializer(Profile.objects.get(User.objects.get(pk=serializers.data['id'])))
    def profile_info(self, obj): 
        # print ('selffff   ', serializers)
        prof_obj = Profile.objects.get(user=User.objects.get(pk=id))
        return {'id':prof_obj.id}

我有一个用于身份验证的自定义用户，并想为其创建一个序列化程序类，我的自定义用户模型如下所示：

class User (AbstractUser):
        bio = models.TextField(max_length=500, blank=True)
        birth_date = models.DateField(null=True, blank=True)
        image=models.FileField(null=True , blank=True)

而我的序列化器是：

class UserSerializer (serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('username' ,'email' ,'password' ,'firstname' , 'last name' )

我怎么能提到密码字段是密码，并且其内容必须被散列？

我想做一个“评论”表。在表中，将有一个包含创建评论的 user_id 的字段。与评论表相关的用户来自Django默认用户模型。这是评论模型：

class Comment(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    pub_date = models.DateTimeField(auto_now_add=True)

这是评论序列化器：

class CommentSerializer(serializers.ModelSerializer):

    class Meta:
        model = Comment
        fields = '__all__'

这是创建新评论的视图集：

class CommentViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer
    permission_classes = (IsAuthenticated,)

    def perform_create(self, serializer):
        serializer.save(user=self.request.user)

我还将用户与 django rest jwt 集成以进行授权。这是我发送到 API 的标头和数据。

标题：

授权：持有者{jwt token}

内容类型：application/json

身体：

{ "content": "这是评论" }

但我得到这样的回应：

{ "user": [ "此字段为必填项。" ] }

如何修复序列化器，以便它从令牌（request.user）中检索用户？

我有以下序列化程序：

from rest_framework import serializers

from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    """ Serializer for Product object """

    class Meta:
        model = Product
        fields = ['name', 'slug', 'description', 'image', 'price', 'active',]

以及以下测试：

from django.test import TestCase
from django.urls import reverse
from rest_framework.test import APIClient
from rest_framework import status

from .factories import ProductFactory
from .models import Product
from .serializer import ProductSerializer

PRODUCTS_URL = reverse('product-list')

def create_product(**params):
    """ Helper function to create a new product """
    return Product.objects.create(**params)

class PublicProductApiTests(TestCase):
    """
    Test the …

我已经花了几天时间在类似问题中研究这个问题，但无法找到解决方案。这应该很简单，我有一个模型：

model.py

class Item(models.Model):
    """Class to represent an item..."""

    label = models.TextField(null=True)
    name = models.TextField()

    category = models.ForeignKey(   "Category", on_delete=models.SET_NULL,
                                    null=True, default=DEFAULT_CATEGORY_ID)

class Category(models.Model):
    """Class to represent the category of an Item. Like plants, bikes..."""
    name = models.TextField()

    description = models.TextField(null=True)

view.py

class ItemViewset(viewsets.ModelViewSet): # pylint: disable=too-many-ancestors
    """API Endpoint to return the list of items"""
    queryset = Item.objects.all()
    serializer_class = ItemSerializer

serializer.py

class ItemSerializer(serializers.ModelSerializer):
    """Serializer for Item."""

    category = CategorySerializer(read_only=True)

    class Meta: # pylint: disable=too-few-public-methods
        """Class to represent metadata of …