आप Django रेस्ट फ्रेमवर्क में एक नेस्टेड सीरीज़र को कैसे फ़िल्टर करते हैं?

Question 1

Django रेस्ट फ्रेमवर्क में, जब आप किसी अन्य धारावाहिक में नेस्टेड होते हैं, तो आप एक धारावाहिक को कैसे फ़िल्टर करते हैं?

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

मैंने ओरिजिनल व्यूसेट पर एक फ़िल्टर जोड़ने की कोशिश की है, लेकिन यह नेस्टेड परिणामों को फ़िल्टर नहीं करता है क्योंकि नेस्टेड परिणाम को एक अलग प्री-फ्रेटेड क्वेरी के रूप में कहा जाता है। (नेस्टेड धारावाहिक एक रिवर्स लुकअप है, आप देखते हैं।)

क्या नेस्टेड सीरीज़र में एक get_queryset () ओवरराइड को जोड़ना संभव है (इसे व्यूसेट से बाहर ले जाना), वहां फ़िल्टर को जोड़ना? मैंने कोशिश की है, भी, कोई भाग्य के साथ।

यह वही है जो मैंने कोशिश की, लेकिन यह भी कहा जाता प्रतीत नहीं होता है:

class QuestionnaireSerializer(serializers.ModelSerializer):
    edition = EditionSerializer(read_only=True)
    company = serializers.StringRelatedField(read_only=True)

    class Meta:
        model = Questionnaire

    def get_queryset(self):
        query = super(QuestionnaireSerializer, self).get_queryset(instance)
        if not self.request.user.is_staff:
            query = query.filter(user=self.request.user, edition__hide=False)
        return query

Question 2

आप ListSerializer को उप-वर्ग कर सकते हैं और to_representationविधि को अधिलेखित कर सकते हैं ।

डिफ़ॉल्ट रूप से to_representationविधि data.all()नेस्टेड क्वेरीसेट पर कॉल करती है। तो आपको data = data.filter(**your_filters)विधि को कहने से पहले प्रभावी ढंग से बनाने की आवश्यकता है । फिर आपको अपने उप-सूचीबद्ध लिस्टसियराइज़र को nested serializer के मेटा पर list_serializer_class के रूप में जोड़ना होगा।

उपवर्ग सूची सूची, अधिलेखित to_representationऔर फिर सुपर बुला रहा है
list_serializer_classनेस्टेड सीरीज़लाइज़र पर मेटा के रूप में उप-सूचीबद्ध लिस्ट सेरिज़ाइज़र जोड़ें

यहाँ आपके नमूने के लिए प्रासंगिक कोड है।

class FilteredListSerializer(serializers.ListSerializer):

    def to_representation(self, data):
        data = data.filter(user=self.context['request'].user, edition__hide=False)
        return super(FilteredListSerializer, self).to_representation(data)


class EditionSerializer(serializers.ModelSerializer):

    class Meta:
        list_serializer_class = FilteredListSerializer
        model = Edition


class QuestionnaireSerializer(serializers.ModelSerializer):
    edition = EditionSerializer(read_only=True)
    company = serializers.StringRelatedField(read_only=True)

    class Meta:
        model = Questionnaire

Question 3

एसओ और अन्य स्थानों से कई समाधानों का परीक्षण किया।

Django 2.0 + DRF 3.7.7 के लिए केवल एक कार्यशील समाधान मिला।

मॉडल में एक विधि को परिभाषित करें जिसमें नेस्टेड क्लास है। एक ऐसा फिल्टर क्राफ्ट करें जो आपकी आवश्यकताओं के अनुरूप हो।

class Channel(models.Model):
    name = models.CharField(max_length=40)
    number = models.IntegerField(unique=True)
    active = models.BooleanField(default=True)

    def current_epg(self):
        return Epg.objects.filter(channel=self, end__gt=datetime.now()).order_by("end")[:6]


class Epg(models.Model):
    start = models.DateTimeField()
    end = models.DateTimeField(db_index=True)
    title = models.CharField(max_length=300)
    description = models.CharField(max_length=800)
    channel = models.ForeignKey(Channel, related_name='onair', on_delete=models.CASCADE)

।

class EpgSerializer(serializers.ModelSerializer):
    class Meta:
        model = Epg
        fields = ('channel', 'start', 'end', 'title', 'description',)


class ChannelSerializer(serializers.ModelSerializer):
    onair = EpgSerializer(many=True, read_only=True, source="current_epg")

    class Meta:
        model = Channel
        fields = ('number', 'name', 'onair',)

ध्यान दीजिए source="current_epg"और आपको बात मिल जाएगी।

Question 4

जबकि उपरोक्त सभी उत्तर काम करते हैं, मुझे Django की Prefetchवस्तु का उपयोग सबसे आसान तरीका लगता है।

मान लें कि एक Restaurantओब्ज में बहुत से MenuItemएस हैं, जिनमें से कुछ हैं is_remove == True, और आप केवल उन लोगों को चाहते हैं जिन्हें हटाया नहीं गया है।

में RestaurantViewSet, कुछ करना पसंद है

from django.db.models import Prefetch

queryset = Restaurant.objects.prefetch_related(
    Prefetch('menu_items', queryset=MenuItem.objects.filter(is_removed=False), to_attr='filtered_menu_items')
)

में RestaurantSerializer, कुछ करना पसंद है

class RestaurantSerializer(serializers.ModelSerializer):
    menu_items = MenuItemSerializer(source='filtered_menu_items', many=True, read_only=True)

Question 5

जब एक धारावाहिक को त्वरित किया जाता है और कई = सत्य पारित हो जाते हैं, तो एक सूची सूची का निर्माण किया जाएगा। धारावाहिक वर्ग तब माता-पिता की सूची का एक बच्चा बन जाता है

यह विधि फ़ील्ड के लक्ष्य को मान तर्क के रूप में लेती है, और उस प्रतिनिधित्व को वापस करना चाहिए जिसका उपयोग लक्ष्य को क्रमबद्ध करने के लिए किया जाना चाहिए। मान तर्क आमतौर पर एक मॉडल उदाहरण होगा।

नीचे नेस्टेड सीरियलाइज़र का उदाहरण है

class UserSerializer(serializers.ModelSerializer):
    """ Here many=True is passed, So a ListSerializer instance will be 
     created"""
    system = SystemSerializer(many=True, read_only=True)

    class Meta:
        model = UserProfile
        fields = ('system', 'name')

class FilteredListSerializer(serializers.ListSerializer):
    
    """Serializer to filter the active system, which is a boolen field in 
       System Model. The value argument to to_representation() method is 
      the model instance"""
    
    def to_representation(self, data):
        data = data.filter(system_active=True)
        return super(FilteredListSerializer, self).to_representation(data)

class SystemSerializer(serializers.ModelSerializer):
    mac_id = serializers.CharField(source='id')
    system_name = serializers.CharField(source='name')
    serial_number = serializers.CharField(source='serial')

    class Meta:
        model = System
        list_serializer_class = FilteredListSerializer
        fields = (
            'mac_id', 'serial_number', 'system_name', 'system_active', 
        )

दृश्य में:

class SystemView(viewsets.GenericViewSet, viewsets.ViewSet):
    def retrieve(self, request, email=None):
        data = get_object_or_404(UserProfile.objects.all(), email=email)
        serializer = UserSerializer(data)
        return Response(serializer.data)

Question 6

मुझे यह आसान लगता है, और अधिक सीधे आगे, SerializerMethodFieldधारावाहिक क्षेत्र पर उपयोग करने के लिए जिसे आप फ़िल्टर करना चाहते हैं।

तो आप कुछ इस तरह से करेंगे।

class CarTypesSerializer(serializers.ModelSerializer):

    class Meta:
        model = CarType
        fields = '__all__'


class CarSerializer(serializers.ModelSerializer):

    car_types = serializers.SerializerMethodField()

    class Meta:
        model = Car
        fields = '__all__'

    def get_car_types(self, instance):
        # Filter using the Car model instance and the CarType's related_name
        # (which in this case defaults to car_types_set)
        car_types_instances = instance.car_types_set.filter(brand="Toyota")
        return CarTypesSerializer(car_types_instances, many=True).data

यह आपको serializers.ListSerializerअलग-अलग धारावाहिकों के लिए अलग-अलग फ़िल्टरिंग मानदंडों की आवश्यकता होने पर कई ओवरराइड बनाने से बचाता है ।

यह भी देखने का अतिरिक्त लाभ है कि फिल्टर एक सबक्लास परिभाषा में गोता लगाने के बजाय धारावाहिक के भीतर क्या करता है।

बेशक नकारात्मक पक्ष यह है कि यदि आपके पास कई नेस्टेड ऑब्जेक्ट्स के साथ एक धारावाहिक है जो सभी को किसी तरह से फ़िल्टर करने की आवश्यकता है। यह सीरियल कोड को बहुत बढ़ा सकता है। यह आपके ऊपर है कि आप कैसे फ़िल्टर करना चाहते हैं।

उम्मीद है की यह मदद करेगा!