हाय @loganknecht। मुझे कहना है, इस तरह के एक अद्भुत मुद्दे की रिपोर्ट के लिए धन्यवाद। यह अच्छी तरह से शुरू होता है, और बस बेहतर हो जाता है। बस इतना स्पष्ट। इसलिए धन्यवाद।

सबसे पहले: ऐसा लगता है कि आपने SchoolOrderingFilter को फ़ील्ड नाम o साथ परिभाषित किया है:

o = SchoolOrderingFilter(...)

तो जब आप कहते हैं:

मैं जो अनुरोध कर रहा हूं वह इस तरह दिखता है
{{API_URL}}/api/v1/schools/?offset=5&limit=3&ordering=learner_enrolled_count

मुझे उम्मीद है कि क्वेरी स्ट्रिंग पैरामीटर o भी होगा। क्या यह काम करता है: {{API_URL}}/api/v1/schools/?offset=5&limit=3&o=learner_enrolled_count ?

फिर (मैं आपकी रिपोर्ट के बारे में थोड़ा अनिश्चित हूं) आप कहते हैं it´sa _computed field_ -- वास्तव में आपका क्या मतलब है? यानी यह एक ऐसा क्षेत्र है जो मॉडल पर दिखाई देता है, या यह एक पायथन संपत्ति है?

पूछने का एक और तरीका (इसका हिस्सा) इस क्षेत्र के साथ क्वेरीसेट काम पर order_by() ? यानी यह काम करता है:

SchoolModel.objects.filter(...).order_by(learner_enrolled_count)

@carltongibson यह काफी दिलचस्प है! मुझे उम्मीद नहीं थी कि o परिभाषित ordering पैरामीटर होगा! मुझे समझ में नहीं आया कि दस्तावेज़ीकरण से 😂

o पैरामीटर का उपयोग करना

क्या दिलचस्प है अगर मैं क्वेरी का उपयोग करता हूं
{{API_URL}}/api/v1/schools/?offset=5&limit=3&o=learner_enrolled_count

मुझे ये परिणाम मिलते हैं:

{
    "schools": [
        {
            "id": 6,
            "name": "Piano Gym Six",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 0
        },
        {
            "id": 8,
            "name": "Piano Gym Eight",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 0
        },
        {
            "id": 9,
            "name": "Piano Gym Nine",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 0
        }
    ]
}

इसके बारे में दिलचस्प बात यह है कि अब मैं जिस एक स्कूल को शीर्ष पर ऑर्डर करना चाहता हूं वह इस खोज परिणाम में नहीं है। जिसका अर्थ है कि यह संभवतः आदेश दिया गया था लेकिन पेजिनेशन अभी भी परिणाम ऑफसेट कर रहा है। हालाँकि जब मैंने learner_enrolled_count का उपयोग किया तो यह अंतिम स्थान पर था।
{{API_URL}}/api/v1/schools/?limit=3&o=learner_enrolled_count

इसलिए मैंने -learner_enrolled_count का उपयोग करके इसका परीक्षण किया (ऑफ़सेट को हटाकर और अवरोही द्वारा क्रमबद्ध करना)
{{API_URL}}/api/v1/schools/?limit=3&o=-learner_enrolled_count
और यह प्रतिक्रिया मिली

{
    "schools": [
        {
            "id": 7,
            "name": "Piano Gym Seven",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 1
        },
        {
            "id": 1,
            "name": "Piano Gym",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 0
        },
        {
            "id": 2,
            "name": "Piano Gym Two",
            "courses": [
                # ...
            ],
            "learner_enrolled_count": 0
        }
    ]
}

ऐसा लगता है कि यह काम किया!

परिकलित क्षेत्र

learner_enrolled_count मॉडल पर ही मौजूद नहीं है। मैंने इसकी गणना करने और परिणामों में इसे इंजेक्ट करने के लिए एक एनोटेशन का उपयोग किया।

डेटा मॉडल में बहुत अधिक गोता लगाने के जोखिम पर, यह समापन बिंदु स्कूलों की सूची के लिए प्रश्नों को फ़िल्टर करने और क्रमबद्ध करने के लिए एक एकल प्रवेश बिंदु है।

मुझे इस तरह के मॉडल पुनर्प्राप्ति का उपयोग करके इस समापन बिंदु को अनुकूलित करना होगा:

class SchoolModelManager(Manager):
    def getBrowseSchoolsData(self, *args, **kwargs):
        """Return all Schools that contain lessons with flash card sets.

        Does not exclude empty sets, just requires that the school has something
        to enroll in
        """
        # WARNING: This MUST be imported here otherwise the compilation fails
        #          because of circular dependencies
        from piano_gym_api.versions.v1.models.flash_card_model import FlashCardModel
        # from piano_gym_api.versions.v1.models.flash_card_model import PlaySheetMusicFlashCardModel
        # from piano_gym_api.versions.v1.models.flash_card_model import TrueOrFalseFlashCardModel
        # from piano_gym_api.versions.v1.models.flash_card_set_model import FlashCardSetModel
        from piano_gym_api.versions.v1.models.sheet_music_model import SheetMusicModel
        # import pdb
        # pdb.set_trace()

        # --------------------
        sheet_music_query_set = (SheetMusicModel.objects.all()
                                 .select_related("school"))
        play_sheet_music_flash_card_sheet_music_prefetch = Prefetch("playsheetmusicflashcardmodel__sheet_music",
                                                                    sheet_music_query_set)
        # --------------------
        flash_card_query_set = (FlashCardModel.objects.all()
                                .select_related("flash_card_set",
                                                "playsheetmusicflashcardmodel",
                                                "school",
                                                "trueorfalseflashcardmodel")
                                .prefetch_related(play_sheet_music_flash_card_sheet_music_prefetch))
        flash_card_prefetch = Prefetch("flash_card_set__flash_card", flash_card_query_set)
        # --------------------
        school_lesson_query_set = (SchoolLessonModel.objects.all()
                                   .select_related("course",
                                                   "flash_card_set",
                                                   "school")
                                   .prefetch_related(flash_card_prefetch))
        school_lesson_prefetch = Prefetch("school_lesson", school_lesson_query_set)
        # --------------------
        school_course_query_set = (SchoolCourseModel.objects.all()
                                   .select_related("school")
                                   .prefetch_related(school_lesson_prefetch))
        school_course_prefetch = Prefetch("school_course", school_course_query_set)
        # --------------------
        query_set_to_return = (SchoolModel.objects.filter(school_lesson__flash_card_set__isnull=False)
                               .distinct()
                               # .annotate(learner_enrolled_count=Count("learner_enrolled_school", distinct=True))
                               .annotate(learner_enrolled_count=Case(
                                   When(learner_enrolled_school__learner_enrolled_course__learner_enrolled_lesson__is_enrolled=True,
                                        then=1),
                                   default=0,
                                   output_field=IntegerField())
        ).prefetch_related(school_course_prefetch))

        return query_set_to_return

calculated field बिट query_set_to_return चर में है। यह जो करता है वह कुल नामांकित शिक्षार्थियों के count और annotates को learner_enrolled_count । मुझे नहीं पता कि यह हासिल करने का यह सही तरीका है, लेकिन ऐसा लगता है कि यह काम करता है

सुझाव

एक सुझाव मैं प्रलेखन में स्पष्ट करना चाहता हूं, या तो अनुरोधों या सरल पाठ के लिए वास्तविक यूआरएल उदाहरणों का उपयोग करना और समझाएं कि उदाहरणों में o ऑर्डर करने के लिए पैरामीटर के रूप में उजागर किया गया है।

निष्कर्ष

ऐसा लगता है कि अब यह सही ढंग से काम कर रहा है कि आपने o पैरामीटर को स्पष्ट कर दिया है कि ऑर्डरिंग फ़िल्टर को क्या सौंपा गया है!

यदि querysets मैं filter लिए प्रदान कर रहा हूं तो उनमें पहले से ही एक एनोटेट फ़ील्ड है - ऐसा लगता है, मेरे परीक्षण से, कि मैं अपना स्वयं का कस्टम OrderingFilter बनाने के लिए बाध्य नहीं हूं

तो उसके कारण मुझे लगता है कि मैं इसके बजाय एक साधारण OrderingFilter उपयोग कर सकता हूं!

मुझे सही जवाब दो अगर मैं गलत हूँ!

मुझे विश्वास है कि यह मेरी उलझन को हल करता है! शुक्रिया!

हाय @loganknecht। सुपर, ऐसा लगता है कि आपने इसे काम कर लिया है। मैं

यदि आप एनोटेशन का उपयोग कर रहे हैं तो आप मानक वर्ग हाँ के साथ उस पर फ़िल्टर और ऑर्डर करने में सक्षम होना चाहिए।

मैं डॉक्स के लिए एक ट्वीक करूँगा।

आपके सहयोग के लिए धन्यवाद।

@carltongibson और बाकी सभी, अद्भुत पुस्तकालय के लिए धन्यवाद!