Django-rest-framework: दस्तावेज़ संबंधित फ़ील्ड के लिए अनुमतियों और फ़िल्टरिंग को कैसे प्रबंधित करें।

मैंने कोड के माध्यम से खुदाई करने की कोशिश की, लेकिन मुझे ऐसा करने का एक आसान तरीका नहीं मिला। आदर्श रूप से, आप प्रत्येक संबंधित वस्तु के लिए अनुमतियों को "has_object_permission" कॉल करने में सक्षम होना चाहिए। अभी, धारावाहिक के पास अनुमति वस्तु तक पहुंच नहीं है।

अभी, धारावाहिक के पास अनुमति वस्तु तक पहुंच नहीं है।

सिवाय इसके कि यह इतना सरल नहीं है।

_कौन सी_ अनुमति वस्तु? ये _other_ ऑब्जेक्ट से संबंध हैं, इसलिए वर्तमान दृश्य पर अनुमति और फ़िल्टर कक्षाएं आवश्यक रूप से वही नियम नहीं होंगे जिन्हें आप ऑब्जेक्ट संबंधों पर लागू करना चाहते हैं।

हाइपरलिंक किए गए रिश्तों के लिए आप सिद्धांत रूप में उस दृश्य को निर्धारित कर सकते हैं जो उन्होंने (+) पर इंगित किया था और उसके आधार पर फ़िल्टरिंग/अनुमतियां निर्धारित करते थे, लेकिन यह निश्चित रूप से एक भयानक कसकर-युग्मित डिज़ाइन के रूप में समाप्त हो जाएगा। गैर-हाइपरलिंक्ड रिश्तों के लिए आप ऐसा भी नहीं कर सकते। इस बात की कोई गारंटी नहीं है कि प्रत्येक मॉडल एक बार एकल विहित दृश्य पर प्रदर्शित होता है, इसलिए आप उन अनुमतियों को स्वचालित रूप से निर्धारित करने का प्रयास नहीं कर सकते जिन्हें आप गैर-हाइपरलिंक्ड संबंधों के लिए उपयोग करना चाहते हैं।

(+) वास्तव में किसी भी _sensible_ तरीके से ऐसा करना वास्तव में संभव नहीं है, लेकिन आइए इस समय का नाटक करें।

शायद एक "has__permission"? प्रत्येक अनुमति वस्तु तब यह बताने में सक्षम होगी कि कौन सी संबंधित वस्तुएँ देखने योग्य हैं या नहीं।

लोग फ़िल्टरिंग का उपयोग कैसे करते हैं? क्या वे इसका उपयोग केवल उन वस्तुओं को छिपाने के लिए कर रहे हैं जिनके पास उपयोगकर्ता की अनुमति नहीं है? क्योंकि अगर यह उपयोग का मामला है, तो शायद फिल्टर की जरूरत नहीं है।

संदर्भित मुद्दों में से एक #1646 संबंधित क्षेत्रों के लिए ब्राउज़ करने योग्य एपीआई पृष्ठों पर दिखाए गए विकल्पों को सीमित करने से संबंधित है।

मुझे ब्राउज़ करने योग्य एपीआई पसंद है और मुझे लगता है कि यह न केवल मेरे लिए बैकएंड डेवलपर के रूप में बल्कि आरईएसटी एपीआई के फ्रंट एंड डेवलपर्स/उपयोगकर्ताओं के लिए भी एक अच्छा टूल है। मुझे ब्राउज़ करने योग्य एपीआई के साथ उत्पाद को शिप करना अच्छा लगेगा (यानी .. यह तब भी चलता है जब साइट DEBUG मोड में अकेली नहीं होती है)। मेरे लिए ऐसा करने में सक्षम होने के लिए, मैं ब्राउज़ करने योग्य एपीआई पृष्ठों के माध्यम से सूचना रिसाव नहीं कर सकता। (यह निश्चित रूप से आवश्यकता के अतिरिक्त है कि वे पृष्ठ आम तौर पर उत्पादन के लिए तैयार और सुरक्षित हैं)।

इसका मतलब यह है कि संबंधित क्षेत्रों के अस्तित्व के बारे में अधिक जानकारी HTML पृष्ठों के माध्यम से सीखने योग्य नहीं होनी चाहिए, जो पोस्टिंग के माध्यम से सीखने योग्य होगी।

मैंने अपने धारावाहिकों के लिए एक मिश्रित वर्ग तैयार किया जो फ़िल्टरिंग प्रदान करने के लिए संबंधित फ़ील्ड के दृश्य का उपयोग करता है।

class RelatedFieldPermissionsSerializerMixin(object):
    """
    Limit related fields based on the permissions in the related object's view.

    To use, mixin the class, and add a dictionary to the Serializer's Meta class
    named "related_queryset_filters" mapping the field name to the string name 
    of the appropriate view class.  Example:

    class MySerializer(serializers.ModelSerializer):
        class Meta:
            related_queryset_filters = {
                'user': 'UserViewSet',
            }

    """
    def __init__(self, *args, **kwargs):
        super(RelatedFieldPermissionsSerializerMixin, self).__init__(*args, **kwargs)
        self._filter_related_fields_for_html()

    def _filter_related_fields_for_html(self):
        """
        Ensure thatk related fields are ownership filtered for
        the browseable HTML views.
        """
        import views
        try:
            # related_queryset_filters is a map of the fieldname and the viewset name (str)
            related_queryset_filters = self.Meta.related_queryset_filters
        except AttributeError:
            related_queryset_filters = {}
        for field, viewset in related_queryset_filters.items():
            try:
                self.fields[field].queryset = self._filter_related_qs(self.context['request'], getattr(views, viewset))
            except KeyError:
                pass

    def _filter_related_qs(self, request, ViewSet):
        """
        Helper function to filter related fields using
        existing filtering logic in ViewSets.
        """
        view = ViewSet()
        view.request = request
        view.action = 'retrieve'
        queryset =  view.get_queryset()
        try:
            return view.queryset_ownership_filter(queryset)
        except AttributeError:
            return queryset

मैंने इसे एक व्यू मिक्सिन का उपयोग करके हल किया: #1935 सीरियलाइज़र और व्यू को मिलाने के बजाय। एक शब्दकोश की आवश्यकता के बजाय, मैंने अभी दृश्य पर secured_fields की एक सूची का उपयोग किया है।

मैंने संबंधित क्षेत्रों में क्वेरीसेट को फ़िल्टर करने के लिए इस सरल सीरिएलाइज़र मिक्सिन का उपयोग किया है:

class FilterRelatedMixin(object):
    def __init__(self, *args, **kwargs):
        super(FilterRelatedMixin, self).__init__(*args, **kwargs)
        for name, field in self.fields.iteritems():
            if isinstance(field, serializers.RelatedField):
                method_name = 'filter_%s' % name
                try:
                    func = getattr(self, method_name)
                except AttributeError:
                    pass
                else:
                    field.queryset = func(field.queryset)

उपयोग भी सरल है:

class SocialPageSerializer(FilterRelatedMixin, serializers.ModelSerializer):
    account = serializers.PrimaryKeyRelatedField()

    class Meta:
        model = models.SocialPage

    def filter_account(self, queryset):
        request = self.context['request']
        return queryset.filter(user=request.user)

यह कैसा है? क्या आप इसमें कोई समस्या देखते हैं?

मेरे लिए, मैं सीरियलाइज़र से उपयोगकर्ताओं और अनुरोधों के बारे में तर्क रखना पसंद करता हूं और इसे दृश्य में छोड़ देता हूं।

समस्या संबंधित क्षेत्रों के साथ है। एक उपयोगकर्ता के पास दृश्य तक पहुंच हो सकती है लेकिन
सभी संबंधित वस्तुओं के लिए नहीं।

बुध, नवंबर 5, 2014 को शाम 6:16 बजे, एलेक्स रोथबर्ग सूचनाएं @github.com
लिखा था:

मेरे लिए, मैं उपयोगकर्ताओं और अनुरोधों के बारे में तर्क को बाहर रखना पसंद करता हूं
Serializer और उस दृश्य में छोड़ दें।

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/tomchristie/django-rest-framework/issues/1985#issuecomment -61873766
.

कृपया इसे पढ़ें, ऐसा लगता है कि यह संबंधित विषय है। हम विकल्प विधि और पोस्ट या पुट विधि के लिए मेटा (मॉडलसेरियलाइज़र) की फ़िल्टरिंग संबंधित फ़ील्ड ऑब्जेक्ट्स को कैसे अलग कर सकते हैं?

https://groups.google.com/forum/#!topic/django -rest-framework/jMePw1vS66A

यदि हम मॉडल = सीरियलाइज़र सेट करते हैं। प्राइमरीकेरिलेटेडफिल्ड (क्वेरीसेट = मॉडल.ऑब्जेक्ट्स.कोई नहीं ()), तो हम संबंधित मॉडल इंस्टेंस के साथ वर्तमान ऑब्जेक्ट को सहेज नहीं सकते हैं, क्योंकि सीलाइज़र प्राइमरीकेरिलेटेडफिल्ड "फ़ील्ड इनपुट को मान्य करते समय मॉडल इंस्टेंस लुकअप के लिए उपयोग किया जाने वाला क्वेरीसेट"।

यदि मॉडल = सीरियलाइज़र। प्राइमरीकेरिलेटेडफिल्ड (क्वेरीसेट = मॉडल.ऑब्जेक्ट्स.ऑल ()) (मॉडलसेरियलाइज़र के लिए डिफ़ॉल्ट के रूप में हम इस पर टिप्पणी कर सकते हैं), तो सभी "संबंधित" ऑब्जेक्ट (वे वास्तव में संबंधित नहीं हैं, क्योंकि विकल्प प्रदर्शन क्रियाएं (पोस्ट, पुट) मुख्य मॉडल वर्ग के लिए गुण, संबंधित वस्तुओं के साथ उदाहरण नहीं) "मॉडल" फ़ील्ड (विकल्प विधि) के विकल्पों में प्रदर्शित होते हैं।

अपडेट करें। @ कैनकन101 +1। लेकिन न केवल "उपयोगकर्ता"। मुझे लगता है, यह बुरा विचार है तर्क और धारावाहिक मिश्रण, जैसा कि मैं धारावाहिकों में क्वेरीसेट देखता हूं: "serializers.PrimaryKeyRelatedField(queryset=".

बेशक, यह अच्छा है:

क्लास मॉडलसेरियलाइज़र:
वर्ग मेटा:
मॉडल = मॉडल

क्योंकि सीरियलाइज़र को यह जानना होगा कि मॉडल से स्वचालित रूप से कैसे और कौन से फ़ील्ड बना रहे हैं।

फिर भी, मैं गलत हो सकता था।

यह काम करने लगता है:

class BlogSerializer(serializers.ModelSerializer):

    entries = serializers.SerializerMethodField()

    class Meta:
        model = Blog

    def get_entries(self, obj):
        queryset = obj.entries.all()
        if 'request' in self.context:
            queryset = queryset.filter(author=self.context['request'].user)
        serializer = EntrySerializer(queryset, many=True, context=self.context)
        return serializer.data

@dustinfarris जो इसे केवल पढ़ने के लिए फ़ील्ड बनाता है ... लेकिन यह काम करता है।

एक ऐसी समस्या का सामना करना पड़ा जो इस धागे से संबंधित प्रतीत होती है। जब एक फ़िल्टरिंग बैकएंड (मेरे मामले में डीजेंगो फ़िल्टर) सक्षम होता है तो ब्राउज़ करने योग्य एपीआई इंटरफ़ेस में Filters बटन जोड़ता है और जहां तक ​​​​मैं कह सकता हूं कि ड्रॉपडाउन फ़ील्ड पर सेट किए गए क्वेरीसेट का सम्मान नहीं करता है। मुझे ऐसा लगता है जैसे इसे करना चाहिए।

उदाहरण:

class Item(models.Model):
    project = models.ForeignKey(Project)

class ItemSerializer(serializers.ModelSerializer):
    def __init__(self, *args, **kwargs):
        request = kwargs.get('context', {}).get('request')
        self.fields['project'].queryset = request.user.project_set.all()
        super(ItemSerializer, self).__init__(*args, **kwargs)

ऊपर दिया गया उदाहरण आइटम को जोड़ने/संपादित करने के फ़ॉर्म के प्रोजेक्ट ड्रॉपडाउन को सही प्रोजेक्ट तक सीमित करता है लेकिन सब कुछ अभी भी Filters ड्रॉपडाउन में दिखाई देता है।

नेलगन के दृष्टिकोण ने मेरे लिए बहुत अच्छा काम किया है, लेकिन केवल एक से कई संबंधों के लिए। अब, मेरे पास एक मॉडल है जहां मेरा रिश्ता एक बहुत से कई फ़ील्ड है। इस मामले में, मिक्सिन दृष्टिकोण काम नहीं करता है। कोई विचार इनके लिए इसे कैसे हल किया जाए?

@fibbs निम्नलिखित जोड़कर

            if isinstance(field, serializers.ManyRelatedField):
                method_name = 'filter_%s' % name
                try:
                    func = getattr(self, method_name)
                except AttributeError:
                    pass
                else:
                    field.child_relation.queryset = func(field.child_relation.queryset) 

जाहिरा तौर पर किसी ने इसके लिए एक स्वच्छ समाधान का योगदान दिया और यह अब बिना इनिट विधियों को हैक किए संभव है: https://medium.com/django-rest-framework/limit-संबंधित- डेटा-choices-with-django-rest-framework-c54e96f5815e

मुझे आश्चर्य है कि यह धागा अद्यतन/बंद क्यों नहीं किया गया है?

कि कोई मैं हूं;)
अच्छी बात है, मैं इसे बंद करने जा रहा हूँ क्योंकि #3605 पहले से ही इसके बारे में दस्तावेज़ीकरण में कुछ जोड़ता है।
अगर कोई कुछ लेकर आ सकता है तो हम अभी भी उस हिस्से में और सुधार पर विचार करेंगे।

यह बहुत अच्छा है कि संबंधित फ़ील्ड के लिए get_queryset() विधि अब मौजूद है। हालांकि यह नेस्टेड सीरियलाइज़र के लिए भी बहुत अच्छा होगा!

शायद। इसके साथ आगे बढ़ना चाहते हैं? :)

वाह ... अद्भुत, अगर यह दस्तावेज है, तो क्या आप मुझे सही दिशा में इंगित कर सकते हैं? मुझे यह पता लगाने में काफी समय लगा!

संपादन के लिए मेरी समस्या का सारांश यहां दिया गया है:

इस उदाहरण के लिए, मेरे मॉडल नाम "तैनातीEnvs" और "होस्ट" हैं।
DeployedEnvs में होस्ट मॉडल के लिए एक विदेशी कुंजी होती है (अर्थात कई परिनियोजितEnvs एक ही होस्ट को इंगित कर सकते हैं)। मुझे होस्ट के लिए पीके के बजाय होस्ट के fqdn फ़ील्ड को प्रदर्शित करने के लिए सीरियलाइज़र की आवश्यकता थी (मैंने इसके लिए स्लग संबंधित फ़ील्ड का उपयोग किया था जो कि बहुत आसान था)। FQDN फ़ील्ड द्वारा प्रासंगिक HOST के लिए FK मान देखकर होस्ट को निर्दिष्ट करने में सक्षम होने के लिए, एक परिनियोजितEnv प्रविष्टि (POST) बनाते समय भी मुझे इसकी आवश्यकता थी। उदाहरण: मैच host.fqdn फ़ील्ड के साथ होस्ट ऑब्जेक्ट के लिए PK को देखकर फ़ील्ड होस्ट (प्रासंगिक होस्ट ऑब्जेक्ट के मिलान fqdn पर सेट) के साथ परिनियोजितEnv बनाएं।

दुर्भाग्य से मैं ड्रॉप डाउन बार में लौटाए गए परिणामों को वर्तमान उपयोगकर्ता के स्वामित्व वाली होस्ट ऑब्जेक्ट्स के विकल्पों तक सीमित नहीं कर सका।

slugRelatedField का उपयोग करने के लिए अनुकूलित मेरा फिक्स कोड यहां दिया गया है:

class UserHostsOnly(serializers.SlugRelatedField):
    def get_queryset(self):
        user = self.context['request'].user
        queryset = Host.objects.filter(owner=user)
        return queryset

class deployEnvSerializer(serializers.ModelSerializer):
    host = UserHostsOnly(slug_field='fqdn')

मैं Django में लगभग 5 किताबें हूं (यदि आप चाहें तो मैं उन सभी को सूचीबद्ध कर सकता हूं), और कोई भी संदर्भ ग्रंथ यह नहीं दिखाता है कि फ्रेमवर्क के इस विशेष क्षेत्र/कार्यक्षमता के साथ कैसे काम करना है। पहले तो मुझे लगा कि मैं कुछ गलत कर रहा हूँ, है ना? क्या मैं जो करने की कोशिश कर रहा हूं उसे करने का कोई बेहतर तरीका है? बेझिझक मुझसे OOB संपर्क करें ताकि मैं इस मुद्दे के लिए टिप्पणियों में हेरफेर न करूं। मेरी टिप्पणी पढ़ने के लिए समय निकालने के लिए सभी को धन्यवाद (एक django नौसिखिया के रूप में, यह पता लगाना वाकई मुश्किल था)।

@एलसीस्टाइल

DRF में प्रत्येक Field ( Serializers सहित) में डेटा को अंदर और बाहर क्रमबद्ध करने के लिए 2 मुख्य तरीके हैं (यानी JSON और पायथन प्रकारों के बीच):

1. to_representation - डेटा "बाहर" जा रहा है
2. to_internal_value - डेटा "इन" आ रहा है

आपके द्वारा प्रदान किए गए मॉडलों की मोटे तौर पर रूपरेखा को छोड़कर, संबंधित फ़ील्ड कैसे काम करते हैं, इसकी एक रूपरेखा नीचे दी गई है, जिसमें SlugRelatedField एक विशेष संस्करण है:

class UserHostsRelatedField(serializers.RelatedField):
    def get_queryset(self):
        # do any permission checks and filtering here
        return Host.objects.filter(user=self.context['request'].user)

    def to_representation(self, obj):
        # this is the data that "goes out"
        # convert a Python ORM object into a string value, that will in turn be shown in the JSON
        return str(obj.fqdn)

    def to_internal_value(self, data):
        # turn an INCOMING JSON value into a Python value, in this case a Django ORM object
        # lets say the value 'ADSF-1234'  comes into the serializer, you want to grab it from the ORM
        return self.get_queryset().get(fqdn=data)

वास्तव में, आप आम तौर पर सुरक्षा जैसी चीज़ों के लिए get_queryset या to_internal_value विधियों में चेक का एक गुच्छा रखना चाहते हैं (यदि django-guardian या rules जैसी किसी चीज़ का उपयोग कर रहे हैं

एक और पूरा उदाहरण इस तरह दिख सकता है

from rest_framework.exceptions import (
    ValidationError,
    PermissionError,
)
class UserHostsRelatedField(serializers.RelatedField):
    def get_queryset(self):
        return Host.objects.filter(user=self.context['request'].user)

    def to_representation(self, obj):
        return str(obj.fqdn)

    def to_internal_value(self, data):
        if not isinstance(data, str):
            raise ValidationError({'error': 'Host fields must be strings, you passed in type %s' % type(data)})
        try:
            return self.get_queryset().get(fqdn=data)
        except Host.DoesNotExist:
            raise PermissionError({'error': 'You do not have access to this resource'})

कुछ समय पहले @cancan101 ने जो लिखा उसके संबंध में:

एक ऐसी समस्या का सामना करना पड़ा जो इस धागे से संबंधित प्रतीत होती है। जब एक फ़िल्टरिंग बैकएंड (मेरे मामले में डीजेंगो फ़िल्टर) सक्षम होता है तो ब्राउज़ करने योग्य एपीआई इंटरफ़ेस में फ़िल्टर बटन जोड़ता है और जहां तक ​​​​मैं कह सकता हूं कि ड्रॉपडाउन फ़ील्ड पर सेट किए गए क्वेरीसेट का सम्मान नहीं करता है। मुझे ऐसा लगता है जैसे इसे करना चाहिए।

जहाँ तक मैं देख सकता हूँ यह अभी भी सच है। डेटा लीक करने वाले फ़ॉरेनकी फ़ील्ड के लिए कस्टम Filterset फ़ील्ड के माध्यम से इसका उपचार किया जा सकता है, लेकिन @tomchristie मुझे अभी भी लगता है कि इसे 'स्वचालित रूप से' हल किया जाना चाहिए और फ़िल्टर मॉडलचॉइस को get_queryset पद्धति का सम्मान करना चाहिए धारावाहिक में कस्टम फ़ील्ड घोषणा की।

किसी भी मामले में इसे अतिरिक्त दस्तावेज की आवश्यकता होगी।

मैं कस्टम फ़िल्टर सेट के माध्यम से इसे हल करने का तरीका नीचे दस्तावेज़ कर रहा हूं:

नमूना वर्केंट्री मॉडल:

class WorkEntry(models.Model):
   date = models.DateField(blank=False, null=True, default=date.today)
   who = models.ForeignKey(User, on_delete=models.CASCADE)
   ...

बेस मॉडल व्यू सेट:

class WorkEntryViewSet(viewsets.ModelViewSet):
   queryset = WorkEntry.objects.all().order_by('-date')
   # only work entries that are owned by request.user are returned
   filter_backends = (OnlyShowWorkEntriesThatAreOwnedByRequestUserFilterBackend, ...)
   # 
   filter_fields = (
      # this shows a filter dropdown that contains User.objects.all() - data leakage!
      'who',
   )
   # Solution: this overrides filter_fields above
   filter_class = WorkentryFilter

कस्टम फ़िल्टरसेट (आधार मॉडल के दृश्य सेट में फ़िल्टर_क्लास के माध्यम से filter_fields को ओवरराइड करता है)

class WorkentryFilter(FilterSet):
    """
    This sets the available filters and filter types
    """
    # foreignkey fields need to be overridden otherwise the browseable API will show User.objects.all()
    # data leakage!
    who = ModelChoiceFilter(queryset=who_filter_function)

    class Meta:
        model = WorkEntry
        fields = {
            'who': ('exact',),
        }

यहां दस्तावेज के रूप में कॉल करने योग्य क्वेरीसेट: http://django-filter.readthedocs.io/en/latest/ref/filters.html#modelchoicefilter

def who_filter_function(request):
    if request is None:
        return User.objects.none()
   # this solves the data leakage via the filter dropdown
   return User.objects.filter(pk=request.user.pk)

@macolo

इस कोड पर एक नज़र डालें:

क्या यह उस डेटा रिसाव की समस्या को ठीक नहीं करता जिसका आप उल्लेख कर रहे हैं? मेरे खोज फ़ील्ड ब्राउज़ करने योग्य एपीआई में मौजूद हैं, लेकिन फिर भी परिणाम अभी भी स्वामी द्वारा फ़िल्टर किए गए क्वेरीसेट तक ही सीमित हैं।

class HostsViewSet(DefaultsMixin, viewsets.ModelViewSet):
    search_fields = ('hostname','fqdn')
    def get_queryset(self):
        owner = self.request.user
        queryset = Host.objects.filter(owner=owner)
        return queryset

@Lcstyle मैं मेजबानों को फ़िल्टर करने की कोशिश नहीं कर रहा हूं, मैं संबंधित क्षेत्र के उदाहरणों को फ़िल्टर करने का प्रयास कर रहा हूं (उदाहरण के लिए मेजबान के मालिक)

मैं इस विशेष समस्या को देख रहा हूं जिसे मैं अपने आरईएसटी में हल करना चाहता हूं ... आमतौर पर उदाहरण request.user पर आधारित होते हैं। मैं थोड़ा और जटिल मामला संभालना चाहता हूं।

मान लें कि मेरे पास Company जिसके पास Employees और Company में महीने के कर्मचारी की विशेषता है:

class Company(Model):
   employee_of_the_month = ForeignKey(Employee)
   ...

class Employee(Model):
    company = ForeignKey(Company)

मैं चाहता हूं कि आरईएसटी इंटरफ़ेस employee_of_the_month को Employee द्वारा उसी company.id साथ Company रूप में सीमित करे।

मैं अब तक यही लेकर आया हूं,

class CompanySerializer(ModelSerializer):
   employee_of_the_month_id = PrimaryKeyRelatedField(
     source='employee_of_the_month',
     queryset=Employee.objects.all())

   def __init__(self, *args, **kwargs):                                        
        super(CompanySerializer, self).__init__(*args, **kwargs)              
        view = self.context.get('view', None)                                   
        company_id = None                                                     
        if view and isinstance(view, mixins.RetrieveModelMixin):                
            obj = view.get_object()                                             
            if isinstance(obj, Company):   #  We could get the model from the queryset.                                     
                company_id = obj.id                                           
        q = self.fields['employee_of_the_month_id'].queryset
        self.fields['employee_of_the_month_id'].queryset = q.filter(company_id=company_id)

... क्या यह तरीका कुछ ऐसा है जिसे सारगर्भित किया जा सकता है? यह थोड़ा सा @nailgun के https://github.com/encode/django-rest-framework/issues/1985#issuecomment -61871134 पर आधारित है

मैं भी सोच रहा हूँ कि मैं कर सकता भी validate() कि employee_of_the_month संतुष्ट क्वेरीसमूह एक ऐसा करने के लिए कोशिश कर रहा द्वारा ऊपर बनाया get() साथ क्वेरीसमूह के खिलाफ employee_of_the_month.id

#3605 को देखते हुए मैं देख रहा हूं कि यह क्षेत्र के लिए एक कस्टम सीरिएलाइज़र के साथ भी किया जा सकता है - आइए कर्मचारी के महीने के बजाय सीईओ का उपयोग करें:

 class CEOField(serializers.PrimaryKeyRelatedField):                 

      def get_queryset(self):                                                     
          company_id = None                                                     
          view = self.context.get('view', None)                                   
          if view and isinstance(view, mixins.RetrieveModelMixin):                
              obj = view.get_object()                                             
              if isinstance(obj, Company):                                      
                  dashboard_id = obj.id                                           
          return Employee.objects.filter(company_id=company_id)           

यह विशेष रूप से चयन के लिए कोई ऑब्जेक्ट वापस करने के लिए डिज़ाइन नहीं किया गया है जब तक कि हम किसी विशिष्ट कंपनी को नहीं देख रहे हों। दूसरे शब्दों में, एक नई कंपनी में तब तक सीईओ नहीं हो सकता जब तक उसके पास कर्मचारी न हों, जो कि कंपनी बनने तक आपके पास नहीं हो सकती।

इस दृष्टिकोण के साथ मेरा एकमात्र खेद यह है कि ऐसा लगता है कि इसे ड्रायर/जेनेरिक बनाया जा सकता है।