Hinzufügen von benutzerspezifischen Feldern zum Django REST Framework-Serializer

Question

Ich möchte ein Feld zu einem Serializer hinzufügen, das spezifische Informationen für den Benutzer enthält, der die aktuelle Anfrage erstellt (ich möchte keinen separaten Endpunkt dafür erstellen). Hier ist die Art, wie ich es tue:

Die Viewset:

class ArticleViewSet(viewsets.ModelViewSet): 
    queryset = Article.objects.all() 
    serializer_class = ArticleSerializer 
    filter_class = ArticleFilterSet 

    def prefetch_likes(self, ids): 
     self.current_user_likes = dict([(like.article_id, like.pk) for like in Like.objects.filter(user=self.request.user, article_id__in=ids)]) 

    def get_object(self, queryset=None): 
     article = super(ArticleViewSet, self).get_object(queryset) 
     self.prefetch_likes([article.pk]) 
     return article 

    def paginate_queryset(self, queryset, page_size=None): 
     page = super(ArticleViewSet, self).paginate_queryset(queryset, page_size) 
     if page is None: 
      return None 

     ids = [article.pk for article in page.object_list] 
     self.prefetch_likes(ids) 

     return page 

Der Serializer:

class ArticleSerializer(serializers.ModelSerializer): 
    class Meta: 
     model = Article 

    def to_native(self, obj): 
     ret = super(ArticleSerializer, self).to_native(obj) 

     if obj: 
      view = self.context['view'] 
      ret['has_liked'] = False 
      if hasattr(view, 'current_user_liked'): 
       ret['has_liked'] = obj.pk in view.current_user_liked 

     return ret 

Gibt es einen besseren Ort, um das Prefetching von gemocht Artikeln zu injizieren, oder Einen schöneren Weg, dies generell zu tun?

Answer 1

Ich würde gerne versuchen, so viel wie möglich auf das Like Modellobjekt zu setzen und dann den Rest in ein benutzerdefiniertes Serializer-Feld zu stecken.

In Serializer Felder können Sie die request über den context Parameter zugreifen, die sie von ihren Eltern erben Serializer .

So könnten Sie so etwas tun:

class LikedByUserField(Field): 
    def to_native(self, article): 
     request = self.context.get('request', None) 
     return Like.user_likes_article(request.user, article) 

Die user_likes_article Klasse Methode könnte dann kapseln Ihre Prefetching (und Caching) Logik.

Ich hoffe, dass hilft.

Answer 2

Sie können es mit SerializerMethodField

Beispiel:

class PostSerializer(serializers.ModelSerializer): 
    fav = serializers.SerializerMethodField('likedByUser') 

    def likedByUser(self, obj): 
     request = self.context.get('request', None) 
     if request is not None: 
      try: 
       liked=Favorite.objects.filter(user=request.user, post=obj.id).count() 
       return liked == 1 
      except Favorite.DoesNotExist: 
       return False 
     return "error" 

    class Meta: 
     model = Post 

dann sollten Sie Serializer aus Sicht wie folgt aufrufen:

class PostView(APIVIEW): 
    def get(self,request): 
     serializers = PostSerializer(PostObjects,context={'request':request}) 

Answer 3

Nach dem Django Documentation - SerializerMethodField musste ich Ändere den Code von rapid2share etwas.

class ResourceSerializer(serializers.ModelSerializer): 
    liked_by_user = serializers.SerializerMethodField() 

    def get_liked_by_user(self, obj : Resource): 
     request = self.context.get('request') 
     return request is not None and obj.likes.filter(user=request.user).exists()