标签: django-serializer

我无法将 ValuesQuerySet 对象序列化为 json 数据，i\xc2\xb4ve 找到了解决此差距的多种解决方案，但这种情况有所不同，因为我需要遵循外键值。

from task_manager.models import UserTasks\ndata=UserTasks.objects.filter(user__username="root",server_id=2).values("server_id__mnemonic")\n

前面的查询返回类似这样的内容：

>>> print data\n[{\'server_id__mnemonic\': u\'lol\'}, {\'server_id__mnemonic\': u\'lol\'}, {\'server_id__mnemonic\': u\'lol\'},.......]\n

但是当我尝试将其序列化为 JSON 格式时，会引发下一个异常：

>>> json_data = serializers.serialize(\'json\',data)\nTraceback (most recent call last):\n  File "<console>", line 1, in <module>\n  File "C:\\Python27\\lib\\site-packages\\django\\core\\serializers\\__init__.py", line 122, in serialize\n    s.serialize(queryset, **options)\n  File "C:\\Python27\\lib\\site-packages\\django\\core\\serializers\\base.py", line 45, in serialize\n    concrete_model = obj._meta.concrete_model\nAttributeError: \'dict\' object has no attribute \'_meta\'\n>>> type(data)\n<class \'django.db.models.query.ValuesQuerySet\'>\n

I\xc2\xb4ve 在 Django 官方手册中找到了一个解决方案：如果您只想序列化字段的子集，则可以为序列化器指定一个 fields 参数：

from django.core import …

我必须为一个事件创建一个约会，我的模型如下 -

事件/模型.py

class Event(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    event_name = models.CharField(max_length=200)
    event_location = models.CharField(max_length=200, default='')

约会/models.py

class Appointment(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    event = models.ForeignKey(Event, on_delete=models.CASCADE)
    appointment_date = models.DateTimeField(default=datetime.datetime.now)

约会序列化程序是-

约会/serializers.py

class AppointmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Appointment
        fields = ('id', 'event', 'appointment_date')

我可以按如下方式创建约会 -

POST appointment

request params -
    event:6625dc74-dc36-4a22-9fac-c63e96fe6049
    appointment_date:2017-06-26 18:30:00


response
    {
      "id": "08c975bc-c4d8-4e90-a4b2-bdb2cd69e9e8",
      "event": "6625dc74-dc36-4a22-9fac-c63e96fe6049",
      "appointment_date": "2017-06-26 18:30:00"
    }

但我需要事件作为事件对象，而不是事件 id 字符串，例如 -

[
  "id": "08c975bc-c4d8-4e90-a4b2-bdb2cd69e9e8",
  "event": {
        "id": "6625dc74-dc36-4a22-9fac-c63e96fe6049",
        "event_name": "Test Event", …

我有两个模型,Appointment和EmployeeEvent.我需要从这些模型中获取数据,并将结果合并到一个get api请求中.

urls.py

url(r'^calenderevents', calender_events)

views.py

@api_view(['GET'])
def calender_events(request):
    queryset1 = Appointment.objects.all()
    queryset2 = EmployeeEvent.objects.all()
    return Response({'Appointments':json.loads(serializers.serialize('json', queryset1)), 'EmployeeEvents': json.loads(serializers.serialize('json', queryset2))})

当我调用API时,我得到结果,但它包含一些不需要的键,如"pk","model","fields"等.另外在命名结果中,我需要完整的客户对象而不是客户ID.有没有办法指定CustomerSerializer和查询集？

结果越来越好了

{
  "Appointments": [
    {
      "pk": "33a0fffb-326e-4566-bfb4-b146a87a4f3f",
      "model": "appointment.appointment",
      "fields": {
        "customer": "25503315-8bac-4070-87c1-86bf0630c846",
        "status": "Requested",
        "description": "Assigned appointment",
      }
    },
    {
      "pk": "9da806f5-77f1-41e6-a745-7be3f79d6f7a",
      "model": "appointment.appointment",
      "fields": {
        "customer": "25503315-8bac-4070-87c1-86bf0630c846",
        "status": "Requested",
        "description": "Assigned appointment",
      }
    }
  ],
  "EmployeeEvents": [
    {
      "pk": "f76b5de0-1ab8-4ac3-947d-15ba8941d97d",
      "model": "employee_event.employeeevent",
      "fields": {
        "event_name": "New Event",

        "start_date": "2017-02-17",
        "end_date": "2017-02-22"
      }
    },
    {
      "pk": "56f02290-370e-426c-951e-a93c57fde681", …

我是 Django1.9 的新手，

模型.py：-

class MyUser(models.Model):

    UserId = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    UserFirstName = models.CharField(max_length=1000)
    UserLastName = models.CharField(max_length=1000)
    UserEmail = models.EmailField(max_length=1000,blank=False,null=True)
    UserContactNumber = models.CharField(max_length=1000)
    UserPassword = models.CharField(max_length=1000)
    IsActive = models.BooleanField(default=False)
    Role = ArrayField(models.CharField(max_length=1000), blank=True,null=True)

    class Meta:
        ordering =('IsActive',)

serializers.py:-

class MyUserSerializer(serializers.ModelSerializer):

    class Meta:
        model = MyUser
        fields = '__all__'

外壳输出：-

>>> from projectmanagement.serializers import MyUserSerializer
>>> users = MyUser.objects.all()
>>> users
[<MyUser: MyUser object>, <MyUser: MyUser object>]
>>> serializer = MyUserSerializer(users,many=True)
>>> serializer
MyUserSerializer([<MyUser: MyUser object>, <MyUser: MyUser object>], many=True):
    UserId …

总的来说，我对 Django 很陌生，所以请不要严厉地评判我。

我有一个自定义用户模型，并使用 DRF 来创建用户配置文件。我在create_user（BaseUserManager 的方法）中规范化电子邮件。我找不到如何标准化 API 序列化程序中电子邮件字段的值的方法。基本上，如果我传递数据库中已存在的电子邮件，但域中仅包含大写字母，它将通过序列化程序的验证，但在以下情况后会遇到完整性错误：

duplicate key value violates unique constraint "accounts_user_email_key" DETAIL: Key (email)=(email@example.com) already exists.

这是我的UserManager方法的简化版本：

class UserManager(BaseUserManager):

    def create_user(self, email, first_name, last_name, password):
        #some validation logic
        #...
        user = self.model(
            email=self.normalize_email(email),
            first_name=first_name,
            last_name=last_name
        )
        user.set_password(password)
        user.save()
        return user

    #other stuff...

这是一个序列化器本身：

class UserSerializer(serializers.ModelSerializer):

    class Meta:
        model = models.User
        fields = ('email', 'first_name', 'last_name', 'password')
        extra_kwargs = {k: {'write_only': True} for k in fields}

    #some password validation...

    def create(self, …

我有一个Object带有state日期时间参数的方法的类dt。如何将日期时间参数从 URL 传递到Object.state()？

该模型：

class Object(models.Model):
    def state(self, dt=datetime.datetime.now()) -> dict:
        ...stuff...
        return {'dt': dt, 'other_stuff': stuff}

风景：

class ObjectDetail(generics.RetrieveAPIView):
    queryset = models.Object.objects.all()
    serializer_class = serializers.ObjectSerializer

    def get_serializer_context(self):
        return {'dt': self.request.query_params.get('dt', datetime.datetime.now())}

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

和序列化器类：

class ObjectSerializer(serializers.HyperlinkedModelSerializer):
    state = StateSerializer(read_only=True, context={'dt': self.context['dt']})

    class Meta:
        model = models.Object
        fields = ('state')

class StateSerializer(serializers.Serializer):
    dt = serializers.DateTimeField()
    ... other stuff...

如您所见，我试图在视图中较早设置上下文dt的行state = StateSerializer(read_only=True, context={'dt': …

我正在尝试序列化我的视图，并且我收到关于 http 状态代码必须是整数的错误，我没有看到必须是整数并作为字符串传递的数据在哪里。我会感谢任何帮助，我是 Django 的新手。我的models.py：

class User(AbstractUser):
    """User model."""

    username = None
    email = models.EmailField(_('email address'), unique=True)
    location = map_fields.AddressField(max_length=200)
    preferred = models.ManyToManyField(Place, related_name='Preferred')
    disliked = models.ManyToManyField(Place, related_name='Disliked')
    maplocation = gis_models.PointField("longitude/latitude", geography=True, blank=False, null=True)
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []

    @classmethod
    def make_preferred(cls, current_email, new_pref_place):
        user, created = cls.objects.get_or_create(
            email=current_email
        )
        user.preferred.add(new_pref_place)

    @classmethod
    def remove_preferred(cls, current_email, pref_place):
        user, created = cls.objects.get_or_create(
            email=current_email
        )
        user.preferred.remove(pref_)lace

    @classmethod
    def make_dislike(cls, current_email, dislike_place):
        user, created = cls.objects.get_or_create(
            email=current_email
        )
        user.disliked.add(dislike_place)

    @classmethod
    def …

我对 Django 序列化程序很陌生，但仍然对它们的工作方式感到困惑。

我有一个相当普遍的场景，其中我正在调用我的 api，它只是在我的模型对象中设置一个字段并保存它（假设记录已经存在并且正在更新）。但是，我需要在保存此模型对象之前对其进行验证。

api.py

@detail_route(methods=['POST'], url_path='submit-draft')
def submit_draft(self, request, *args, **kwargs):
    booking = self.get_object()

    # serializer with custom validations.
    serializer = self.get_serializer(booking)
    serializer.is_valid(raise_exception=True)

    booking.submit_draft(by=request.user)
    booking.save()

    data = serializers.BookingDetailSerializer(booking, context={'request': request}).data

    return response.Ok(data)

序列化程序.py

class BookingCreateUpdateSerializer(serializers.ModelSerializer):
    date = serializers.CharField()

    duration = serializers.IntegerField(required=True, )

    created_by = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault(), )

    modified_by = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault(), )
    ....

    class Meta:
    model = models.Booking
        fields = [
        'title',
        'date',
        'duration',
        'client',
        'created_by',
        'modified_by',
        ....
    ]

但是，我收到此错误：

AssertionError: Cannot call '.is_valid()' as no 'data=' keyword …

假设我有一个定义如下的模型：

from django.core.validators import MinValueValidator, MaxValueValidator, RegexValidator

alphanumeric_validator = RegexValidator(r'^[a-zA-Z0-9]*$', 'Only alphanumeric characters are allowed.')

class Person(model.Model):
    name = models.CharField(max_length=60, validators=[alphanumeric_validator])
    number = models.IntegerField(validators=[MinValueValidator(0), MaxValueValidator(100)])
    email = models.EmailField()

现在，假设我正在使用 Django Rest Framework 序列化和创建 Person 对象。它看起来像这样：

from rest_framework import serializers
from .models import Person
from rest_framework.response import Response

class PersonSerializer(serializers.ModelSerializer):
    class Meta:
        model = Person
        fields = ('name', 'number', 'email')

class PostPerson(APIView):
    def post(self, request, format=None):
        serializer = PersonSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()=
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

现在，我的问题是：当我使用 验证序列化器时is_valid() …

我正在尝试使用 ID 更新多个对象，我将这些 ID 传递给需要更新的每个对象，但找不到任何方法来成功执行此操作。这是我的代码

模型.py

class EventTicket(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid_generate_v1mc, editable=False)
    name = models.CharField(max_length=250)
    description = models.TextField(max_length=1000)

视图.py

  class EventTicketView(APIView, PaginationHandlerMixin):
        permission_classes = (AllowAny,)
        def get_object(self, ticket_id):
            try:
                return EventTicket.objects.get(id=ticket_id)
            except EventTicket.DoesNotExist():
                raise status.HTTP_400_BAD_REQUEST
        def patch(self, request, *args, **kwargs):
            for each_ticket in request.data:

                ticket_id = self.get_object(each_ticket['ticket_id'])

                serializer = EventTicketSerializer(instance=ticket_id,data=request.data,partial=True)
                if serializer.is_valid():
                    serializer.save()
                    result = {
                        'message': "updated sucessfully"
                    }
                    return Response(result, status=status.HTTP_201_CREATED)
                else:
                    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

序列化程序.py

class EventTicketSerializer(serializers.ModelSerializer):
    class Meta:
        model = EventTicket
        fields = ['name', 'description'] …