Django-rest-framework: OrderingFilter의 중첩된 관련 필드에 의한 정렬 지원

이에 대한 풀 리퀘스트를 고려하고 싶지만 스스로 할 시간이 없습니다.

이를 구현하려는 사람은 필터링에 잘못된 필드 이름이 사용될 때 합리적인 동작을 보장해야 합니다. 최소한 결과는 정상적으로 반환되어야 합니다. (이상적으로는 잘못된 필드 이름은 무시해야 하지만 다른 필드는 그대로 두어야 합니다.)

고려하여 나는 이것을 닫을 것입니다. 누군가가 풀 리퀘스트를 발행하고 그것을 처리하는 테스트를 한다면 나는 재고할 수 있지만, 기본 필터링 클래스 각각의 보다 완전한 구현은 실제로 누군가가 제3자 패키지에서 정말 훌륭하게 처리할 수 있고 별도로 유지 관리할 수 있는 것입니다. 기본 문서에서 연결됩니다.

테스트나 문서를 작성할 시간이 없었기 때문에 풀 리퀘스트가 없습니다. 하지만 이것이 다른 사람들이 이 문제를 찾는 데 도움이 되는 경우를 대비하여 다음을 사용하고 있습니다.

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.related.RelatedObject

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 rest framework의 마지막 버전에는 문제가 없었습니다 :)

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에서 사용 중단 경고를 발생시킵니다. 이제 각각 다음과 같습니다.

• field.remote_field
• 필드 모델

@tomchristie 는 이 패치가 4년 동안 이 문제에서 남아 있고(그리고 지속적으로 업데이트되고

그냥 내 0.2 센트

이 패치가 작동합니다. 릴리스 버전에 병합할 수 있습니까?

앞서 말했듯이 타사로 만들거나(선호) 테스트 및 문서와 함께 적절한 PR이 필요합니다.

@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('-'))]

여러분, 이 문제의 4번째 생일을 맞아 이 유용한 순서를 지원하기 위해 DRF와 함께 설치할 외부 패키지를 함께 해킹하기로 결정했습니다.

https://github.com/apiraino/djangorestframework_custom_filters_ordering

작업을 완료하기 위해 다음 일에 작업할 것입니다(즉, 코드를 적절하게 패키징 및 인수분해하고 테스트를 개선하고 적극적으로 지원되는 Django 버전에 대한 지원을 보장해야 함).

물론 기여도 환영합니다!

건배

참조 #5533.

나 엄청 혼란스러워. 이것은 기본적으로 작동하는 것처럼 보입니까?

나는 이 문제에 와서 모든 주석을 읽고 @apiraino로 솔루션을 구현하기 시작했지만 관련 필드의 이름을 잘못 입력했다는 것을 발견했습니다.

그러나 이제 API 결과를 주문하기 위해 이중 중첩 관계에 ?ordering=job__customer__company 를 사용하고 있으며 제대로 작동합니다.

@halfnibble - #5533에서 수정되었다고 생각합니다.

cc @carltongibson

@halfnibble , 어떤 버전을 사용하셨나요? 저는 3.8.2를 사용 중이며 작동하지 않습니다. 내 버전은 다음과 같습니다.

    "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 포함된 경우에만 작동합니다. 그러나 보다 일반적인 솔루션을 위해서는 여전히 패치가 필요합니다.

안녕하세요, 저는 DRF를 처음 접했고 데이터베이스 구조를 노출하지 않고 주문 필드에 주문을 추가하는 방법을 찾고 있었습니다. 예를 들어, z를 찾고 싶다면 x__y__z를 작성해야 하고 이를 매개변수로 엔드포인트에 전달하면 구조가 노출됩니다. 이것이 내가 z라고만 말하고 ORM의 관련 필드인지 확인하기 위해 함수를 검사하도록 하려는 경우에 찾고 있는 것입니까?

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__'