Django-rest-framework: ऑर्डरिंगफ़िल्टर में नेस्टेड संबंधित फ़ील्ड द्वारा ऑर्डर करने के लिए समर्थन

मैं इसके लिए पुल अनुरोधों पर विचार करूंगा, लेकिन ऐसा कुछ नहीं है जो मेरे पास खुद करने का समय होगा।

फ़िल्टरिंग में गलत फ़ील्ड नामों का उपयोग किए जाने पर इसे लागू करने वाले किसी भी व्यक्ति को समझदार व्यवहार सुनिश्चित करने की आवश्यकता होती है। एक न्यूनतम पर परिणाम अभी भी ठीक लौटना चाहिए। (आदर्श रूप से, किसी भी गलत फ़ील्ड नामों को अनदेखा किया जाना चाहिए, लेकिन अन्य फ़ील्ड को छोड़ दिया जाना चाहिए।)

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

कोई पुल अनुरोध नहीं है क्योंकि मेरे पास परीक्षण या दस्तावेज़ लिखने का समय नहीं है, लेकिन अगर यह अन्य लोगों को इस मुद्दे को खोजने में मदद करता है, तो मैं इसका उपयोग कर रहा हूं:

from django.db.models.fields import FieldDoesNotExist 
from rest_framework.filters import OrderingFilter

class RelatedOrderingFilter(OrderingFilter):
    """ 
    Extends OrderingFilter to support ordering by fields in related models
    using the Django ORM __ notation
    """
    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related 
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:
            field, parent_model, direct, m2m = model._meta.get_field_by_name(components[0])
            if field.rel and len(components) == 2:
                return self.is_valid_field(field.rel.to, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, ordering):
        return [term for term in ordering if self.is_valid_field(queryset.model, term.lstrip('-'))]

@rhunwicks आपका संस्करण रिवर्स रिलेशन सॉर्टिंग की अनुमति नहीं देता है, केवल प्रत्यक्ष fk का यहां पैच किया गया संस्करण है

class RelatedOrderingFilter(OrderingFilter):
    """
    Extends OrderingFilter to support ordering by fields in related models
    using the Django ORM __ notation
    """
    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:
            field, parent_model, direct, m2m = \
                model._meta.get_field_by_name(components[0])

            # reverse relation
            if isinstance(field, RelatedObject):
                return self.is_valid_field(field.model, components[1])

            # foreign key
            if field.rel and len(components) == 2:
                return self.is_valid_field(field.rel.to, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, ordering, view):
        return [term for term in ordering
                if self.is_valid_field(queryset.model, term.lstrip('-'))]

pySilver के स्निपेट ने मेरे लिए अच्छा काम किया, क्या हम इसे किसी भी मौके पर DRF में ला सकते हैं?

आप RelatedObject कहाँ से आयात करते हैं? मेरे लिए उपलब्ध नहीं प्रतीत होता है

Python 3.4.3
Django==1.8.5
djangorestframework==3.2.3

@eldamir django.db.models.

ImportError: No module named 'django.db.models.related'

आह, ऐसा लगता है कि इसे 1.8 से हटा दिया गया है, देखें https://code.djangoproject.com/ticket/21414

टिप के लिए धन्यवाद: +1:। लिंक ठीक करने देता है। यह सही है

from django.core.exceptions import FieldDoesNotExist
from django.db.models.fields.related import ForeignObjectRel
from rest_framework.filters import OrderingFilter


class RelatedOrderingFilter(OrderingFilter):
    """
    Extends OrderingFilter to support ordering by fields in related models
    using the Django ORM __ notation
    """
    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:
            field, parent_model, direct, m2m = \
                model._meta.get_field_by_name(components[0])

            # reverse relation
            if isinstance(field, ForeignObjectRel):
                return self.is_valid_field(field.model, components[1])

            # foreign key
            if field.rel and len(components) == 2:
                return self.is_valid_field(field.rel.to, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, ordering, view):
        return [term for term in ordering
                if self.is_valid_field(queryset.model, term.lstrip('-'))]

Django बाकी ढांचे के अंतिम संस्करण के साथ समस्या नहीं थी :)

अपना ordering_fields सही ढंग से निर्दिष्ट करना न भूलें

बस एक नोट - Django> 1.10 में कुछ तरीके बदल गए हैं

विशेष रूप से आपको निम्नलिखित को बदलना होगा:

field, parent_model, direct, m2m = model._meta.get_field_by_name(components[0])
प्रति
field = model._meta.get_field(components[0])

और remove_invalid_fields लिए हस्ताक्षर बदल गया है:

def remove_invalid_fields(self, queryset, ordering, view, request):

जिसके परिणामस्वरूप Django> 1.10 के लिए अंतिम कार्यशील संस्करण:

class RelatedOrderingFilter(OrderingFilter):
    """
    Extends OrderingFilter to support ordering by fields in related models
    using the Django ORM __ notation
    """
    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:

            field = model._meta.get_field(components[0])

            # reverse relation
            if isinstance(field, ForeignObjectRel):
                return self.is_valid_field(field.model, components[1])

            # foreign key
            if field.rel and len(components) == 2:
                return self.is_valid_field(field.rel.to, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, fields, view, request):
        return [term for term in fields if self.is_valid_field(queryset.model, term.lstrip('-'))]

उपरोक्त कोड में OneToOneField के साथ समस्या होगी, इसके लिए एक फिक्स जोड़ना:

from django.core.exceptions import FieldDoesNotExist
from django.db.models.fields.reverse_related import ForeignObjectRel, OneToOneRel

from rest_framework.filters import OrderingFilter


class RelatedOrderingFilter(OrderingFilter):
    """
    Extends OrderingFilter to support ordering by fields in related models.
    """    

    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:

            field = model._meta.get_field(components[0])

            if isinstance(field, OneToOneRel):
                return self.is_valid_field(field.related_model, components[1])

            # reverse relation
            if isinstance(field, ForeignObjectRel):
                return self.is_valid_field(field.model, components[1])

            # foreign key
            if field.rel and len(components) == 2:
                return self.is_valid_field(field.rel.to, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, fields, view):
        return [term for term in fields
                if self.is_valid_field(queryset.model, term.lstrip('-'))]        

field.rel और field.rel.to Django>= 1.10 पर एक बहिष्करण चेतावनी बढ़ाएंगे। वे अब क्रमशः हैं:

• फ़ील्ड.रिमोट_फ़ील्ड
• क्षेत्र.मॉडल

@tomchristie इस पैच पर विचार कर रहा है (और लगातार अपडेट किया जा रहा है) इस मुद्दे में 4 साल के लिए (हम पिछले साल से उत्पादन में इसका इस्तेमाल कर रहे हैं), क्या यह पीआर के लिए उपयुक्त हो सकता है और डीआरएफ में विलय हो सकता है (हां, बैक अप द्वारा समर्थित) Unittests का एक उचित सेट)?

बस मेरा .2 सेंट

यह पैच मेरे लिए काम करता है, क्या हम इसे रिलीज़ संस्करणों में मर्ज कर सकते हैं?

जैसा कि पहले कहा गया है, या तो इसे एक तृतीय पक्ष (पसंदीदा) बनाएं या इसे परीक्षण और दस्तावेज़ीकरण के साथ उचित पीआर की आवश्यकता है।

@filiperinaldi मुझे लगता है कि Django >= 1.10 field.rel.to field.related_model बन जाता है। यहाँ पैच का नवीनतम संस्करण है जो हमारे यूनिटटेस्ट को पास करता है।

nb हम Django 1.11 का उपयोग कर रहे हैं इसलिए ymmw

class RelatedOrderingFilter(filters.OrderingFilter):
    """

    See: https://github.com/tomchristie/django-rest-framework/issues/1005

    Extends OrderingFilter to support ordering by fields in related models
    using the Django ORM __ notation
    """
    def is_valid_field(self, model, field):
        """
        Return true if the field exists within the model (or in the related
        model specified using the Django ORM __ notation)
        """
        components = field.split('__', 1)
        try:
            field = model._meta.get_field(components[0])

            if isinstance(field, OneToOneRel):
                return self.is_valid_field(field.related_model, components[1])

            # reverse relation
            if isinstance(field, ForeignObjectRel):
                return self.is_valid_field(field.model, components[1])

            # foreign key
            if field.remote_field and len(components) == 2:
                return self.is_valid_field(field.related_model, components[1])
            return True
        except FieldDoesNotExist:
            return False

    def remove_invalid_fields(self, queryset, fields, ordering, view):
        return [term for term in fields
                if self.is_valid_field(queryset.model, term.lstrip('-'))]

ठीक है लोग, इस अंक के चौथे जन्मदिन के लिए, मैंने इसे आजमाने का फैसला किया और इस उपयोगी आदेश का समर्थन करने के लिए डीआरएफ के साथ स्थापित किए जाने वाले बाहरी पैकेज को एक साथ हैक करने का फैसला किया:

https://github.com/apiraino/djangorestframework_custom_filters_ordering

मैं काम खत्म करने के लिए अगले दिनों में इस पर काम करूंगा (अर्थात् मुझे कोड को ठीक से पैकेज और फैक्टर करने, परीक्षण को परिष्कृत करने और सक्रिय रूप से समर्थित Django संस्करणों के लिए समर्थन सुनिश्चित करने की आवश्यकता है)।

योगदान का स्वागत है, बिल्कुल!

चियर्स

रेफरी #5533।

मैं बहुत असमंजस में हूँ। यह डिफ़ॉल्ट रूप से काम करता प्रतीत होता है?

मैं इस मुद्दे पर आया, सभी टिप्पणियों को पढ़ा, और @apiraino द्वारा समाधान को लागू करने के लिए आगे

हालांकि, अब मैं एपीआई परिणामों को ऑर्डर करने के लिए डबल नेस्टेड रिश्ते के लिए ?ordering=job__customer__company का उपयोग कर रहा हूं और यह ठीक काम कर रहा है।

@halfnibble - मेरा मानना ​​​​है कि यह # 5533 में तय किया गया था।

सीसी @carltongibson

@ हाफनिबल ,

    "install_requires": [
        "django==2.0.3",
        "coreapi==2.3.3",
        "django-filter==1.1.0",
        "djangorestframework-filters==0.10.2.post0",
        "djangorestframework-queryfields==1.0.0",
        "djangorestframework==3.8.2",
        "django-bulk-update==2.2.0",
        "django-cors-headers==2.4.0",
        "django-rest-auth[with_social]==0.9.2",
        "drf-yasg==1.6.0",
        "django-taggit==0.22.2",
        "google-api-python-client==1.6.2",
        "markdown==2.6.11",
        "pygments==2.2.0",
        "xlrd==1.1.0",
        "xlsxwriter==0.9.8",
        "factory-boy==2.10.0",
        "psycopg2-binary==2.7.4",
        "django-admin-tools==0.8.1"
    ]

क्षमा करें, अब मैं समझ गया। डिफ़ॉल्ट रूप से यह केवल तभी काम करेगा जब संबंधित ऑर्डरिंग पैरामीटर ordering_fields । लेकिन अधिक सामान्य समाधान के लिए अभी भी पैच की आवश्यकता है।

नमस्ते, मैं डीआरएफ के लिए अपेक्षाकृत नया हूं और अपने डेटाबेस की संरचना को उजागर किए बिना अपने ऑर्डर फ़ील्ड में ऑर्डर जोड़ने का तरीका ढूंढ रहा था। उदाहरण के लिए, यदि मैं z की तलाश करना चाहता हूं, तो मुझे x__y__z लिखना होगा, और पैरामीटर के रूप में इसे एंडपॉइंट में पास करना संरचना को उजागर करता है। क्या यह वही है जो मैं ढूंढ रहा हूं अगर मैं केवल z कहना चाहता हूं और यह देखने के लिए फ़ंक्शन जांचता है कि यह ओआरएम में संबंधित फ़ील्ड है या नहीं?

आप OrderingFilter.get_ordering ओवरराइड करने का प्रयास कर सकते हैं। कुछ इस तरह...

class CustomOrderingFilter(OrderingFilter):
    def get_ordering(self, request, queryset, view):
        ordering = super().get_ordering(request, queryset, view)
        field_map = {
            'z': 'x__y__z',
        }
        return [field_map.get(o, o) for o in ordering]

@rpkilby बहुत बहुत धन्यवाद! यही वह है जिसकी तलाश में मैं हूं। मैं मदद की सराहना करता हूं।

यहां एक समाधान है जिसे मैंने एक साथ रखा है:

class RelatedOrderingFilter(filters.OrderingFilter):
    _max_related_depth = 3

    <strong i="6">@staticmethod</strong>
    def _get_verbose_name(field: models.Field, non_verbose_name: str) -> str:
        return field.verbose_name if hasattr(field, 'verbose_name') else non_verbose_name.replace('_', ' ')

    def _retrieve_all_related_fields(
            self,
            fields: Tuple[models.Field],
            model: models.Model,
            depth: int = 0
    ) -> List[tuple]:
        valid_fields = []
        if depth > self._max_related_depth:
            return valid_fields
        for field in fields:
            if field.related_model and field.related_model != model:
                rel_fields = self._retrieve_all_related_fields(
                    field.related_model._meta.get_fields(),
                    field.related_model,
                    depth + 1
                )
                for rel_field in rel_fields:
                    valid_fields.append((
                        f'{field.name}__{rel_field[0]}',
                        self._get_verbose_name(field, rel_field[1])
                    ))
            else:
                valid_fields.append((
                    field.name,
                    self._get_verbose_name(field, field.name),
                ))
        return valid_fields

    def get_valid_fields(self, queryset: models.QuerySet, view, context: dict = None) -> List[tuple]:
        valid_fields = getattr(view, 'ordering_fields', self.ordering_fields)
        if not valid_fields == '__all_related__':
            if not context:
                context = {}
            valid_fields = super().get_valid_fields(queryset, view, context)
        else:
            valid_fields = [
                *self._retrieve_all_related_fields(queryset.model._meta.get_fields(), queryset.model),
                *[(key, key.title().split('__')) for key in queryset.query.annotations]
            ]
        return valid_fields
````

Then I add this to wherever I want to be able to order by all related fields:
```python
filter_backends = (RelatedOrderingFilter,)
ordering_fields = '__all_related__'