Python DjangoRestFramework如何在viewset中获取用户

我正在尝试制作一个friends提要，其中列出了我当前与之为好友的所有“Beat”对象。如何访问视图集中的用户以返回正确的对象

型号：

class Beat(models.Model):
    created_at = models.DateTimeField( default=datetime.now)
    title = models.CharField(max_length=255)
    description = models.TextField(blank=True, null=True)
    likes = models.IntegerField(default=0)
    artist = models.ForeignKey(UserProfile, null=True, blank=True)
    audio = models.FileField(upload_to="media_files/audio/",null=True, blank=True)
    beat_cover = models.ImageField(upload_to="media_files/img/",null=True, blank=True);
    admin_name = models.CharField(max_length=255, blank=True, null=True)

    class Meta:
        ordering = ['-created_at']

     def __unicode__(self):
        return unicode(self.admin_name)



class UserProfile(models.Model):
    user = models.OneToOneField(User, blank=True, null=True)
    admin_name = models.CharField(default="beat",max_length=255,blank=True, null=True)
    profile_pic = models.ImageField(upload_to="media_files/users/")

    def __unicode__(self):
        return unicode(self.admin_name)

序列化程序：

class AllBeatStreamSerializer(serializers.ModelSerializer):

    class Meta:
        model = Beat
        fields = ('created_at', 'title', 'audio', 'artist' )
        depth = 1

视图集：

class FriendsBeatStreamViewSet(viewsets.ModelViewSet):
    user = self.request.user    
    my_battles = Battle.objects.filter(challenging_beat__artist=user)   
    obj = {}
    my_beats = Beat.objects.filter(artist=user)
    related_users = Relationship.objects.filter(from_user=user).values_list('to_user', flat=True).distinct()
    stream = Beat.objects.filter(artist__in=related_users)
    stream = list(my_beats) + list(stream) + list(my_battles)
    queryset = stream

    serializer_class = AllBeatStreamSerializer
    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)

---

您应该在序列化程序（逻辑所属的位置）中重写

queryset

属性，如下所示：

class AllBeatStreamSerializer(serializers.ModelSerializer):
    # ...

    def __init__(self, *args, **kwargs):
        user = kwargs['context']['request'].user

        super(AllBeatStreamSerializer, self).__init__(*args, **kwargs)
        self.fields['parent'].queryset = self.get_request(user)

    def get_request(self, user):   
        my_battles = Battle.objects.filter(challenging_beat__artist=user)   
        obj = {}
        my_beats = Beat.objects.filter(artist=user)
        related_users = Relationship.objects.filter(from_user=user)\
                          .values_list('to_user', flat=True)\
                          .distinct()
        stream = Beat.objects.filter(artist__in=related_users)
        stream = list(my_beats) + list(stream) + list(my_battles)
        queryset = stream

        return queryset

from django.db.models import Q

class FriendsBeatStreamViewSet(viewsets.ModelViewSet):
    serializer_class = AllBeatStreamSerializer
    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)

    def get_queryset(self):
        user = self.request.user

        my_beats = Q(artist=user)

        related_users = Relationship.objects \
            .filter(from_user=user).values_list('to_user', flat=True).distinct()
        stream = Q(artist__in=related_users)

        return Beat.objects.filter(my_beats | stream)

---

对您的问题的直接回答很简单：覆盖

get_queryset

而不是将

queryset

定义为属性，这样您就可以在

self.request.user

上访问当前用户

但是您的代码示例更复杂。1） 您不能将

Battle

对象与

Beat

对象混合使用。2） 序列化程序是

Beat

序列化程序，因此

queryset

必须是

Beat

实例

但是您可以使用SQL中带有

或

原因的过滤器混合许多

节拍的来源，因此您可以得到所有
我的节拍或与我相关的节拍。Django有一个允许复杂查找的。因此，您可以使用
或
操作符
|
连接两个
Q
对象。每个
Q
都带有一个表示
Beat
源的过滤器，如
my beats
或
与我相关的beats

您的代码如下所示：

class AllBeatStreamSerializer(serializers.ModelSerializer):
    # ...

    def __init__(self, *args, **kwargs):
        user = kwargs['context']['request'].user

        super(AllBeatStreamSerializer, self).__init__(*args, **kwargs)
        self.fields['parent'].queryset = self.get_request(user)

    def get_request(self, user):   
        my_battles = Battle.objects.filter(challenging_beat__artist=user)   
        obj = {}
        my_beats = Beat.objects.filter(artist=user)
        related_users = Relationship.objects.filter(from_user=user)\
                          .values_list('to_user', flat=True)\
                          .distinct()
        stream = Beat.objects.filter(artist__in=related_users)
        stream = list(my_beats) + list(stream) + list(my_battles)
        queryset = stream

        return queryset

from django.db.models import Q

class FriendsBeatStreamViewSet(viewsets.ModelViewSet):
    serializer_class = AllBeatStreamSerializer
    permission_classes = (permissions.IsAuthenticatedOrReadOnly,)

    def get_queryset(self):
        user = self.request.user

        my_beats = Q(artist=user)

        related_users = Relationship.objects \
            .filter(from_user=user).values_list('to_user', flat=True).distinct()
        stream = Q(artist__in=related_users)

        return Beat.objects.filter(my_beats | stream)

在序列化程序中

self.context["request"].user

例如：

class AsistenciaReunionSerializer(serializers.ModelSerializer):
    def create(self, validated_data):
        asistencia = AsistenciaReunion.objects.create(persona=validated_data["persona"],
                                                      reunion=validated_data["reunion"],
                                                      registrador=self.context["request"].user).save()
        return asistencia