diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py index 1e7e73d..c385446 100644 --- a/django/db/models/fields/related.py +++ b/django/db/models/fields/related.py @@ -251,18 +251,29 @@ class ReverseSingleRelatedObjectDescriptor(six.with_metaclass(RenameRelatedObjec # a single "remote" value, on the class that defines the related field. # In the example "choice.poll", the poll attribute is a # ReverseSingleRelatedObjectDescriptor instance. - def __init__(self, field_with_rel): + def __init__(self, field_with_rel, manager_class=None): self.field = field_with_rel self.cache_name = self.field.get_cache_name() + if manager_class is None: + self.manager = None + else: + self.manager = manager_class() + self.manager.model = self.field.rel.to + + def is_cached(self, instance): return hasattr(instance, self.cache_name) def get_queryset(self, **db_hints): db = router.db_for_read(self.field.rel.to, **db_hints) - rel_mgr = self.field.rel.to._default_manager + + if self.manager is not None: + return self.manager.using(db) + # If the related manager indicates that it should be used for # related fields, respect that. + rel_mgr = self.field.rel.to._default_manager if getattr(rel_mgr, 'use_for_related_fields', False): return rel_mgr.using(db) else: @@ -368,8 +379,9 @@ class ForeignRelatedObjectsDescriptor(object): # multiple "remote" values and have a ForeignKey pointed at them by # some other model. In the example "poll.choice_set", the choice_set # attribute is a ForeignRelatedObjectsDescriptor instance. - def __init__(self, related): + def __init__(self, related, manager_class=None): self.related = related # RelatedObject instance + self.manager_class = manager_class def __get__(self, instance, instance_type=None): if instance is None: @@ -389,7 +401,7 @@ class ForeignRelatedObjectsDescriptor(object): def related_manager_cls(self): # Dynamically create a class that subclasses the related model's default # manager. - superclass = self.related.model._default_manager.__class__ + superclass = self.manager_class or self.related.model._default_manager.__class__ rel_field = self.related.field rel_model = self.related.model @@ -939,8 +951,12 @@ class ForeignObject(RelatedField): parent_link=kwargs.pop('parent_link', False), on_delete=kwargs.pop('on_delete', CASCADE), ) + kwargs['verbose_name'] = kwargs.get('verbose_name', None) + self.manager_class = kwargs.pop('manager_class', None) + self.reverse_manager_class = kwargs.pop('reverse_manager_class', None) + super(ForeignObject, self).__init__(**kwargs) def resolve_related_fields(self): @@ -1104,13 +1120,15 @@ class ForeignObject(RelatedField): def contribute_to_class(self, cls, name, virtual_only=False): super(ForeignObject, self).contribute_to_class(cls, name, virtual_only=virtual_only) - setattr(cls, self.name, ReverseSingleRelatedObjectDescriptor(self)) + + setattr(cls, self.name, ReverseSingleRelatedObjectDescriptor(self, self.manager_class)) def contribute_to_related_class(self, cls, related): # Internal FK's - i.e., those with a related name ending with '+' - # and swapped models don't get a related descriptor. if not self.rel.is_hidden() and not related.model._meta.swapped: - setattr(cls, related.get_accessor_name(), ForeignRelatedObjectsDescriptor(related)) + + setattr(cls, related.get_accessor_name(), ForeignRelatedObjectsDescriptor(related, self.reverse_manager_class)) if self.rel.limit_choices_to: cls._meta.related_fkey_lookups.append(self.rel.limit_choices_to) diff --git a/tests/custom_field_managers/__init__.py b/tests/custom_field_managers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/custom_field_managers/models.py b/tests/custom_field_managers/models.py new file mode 100644 index 0000000..30dbb94 --- /dev/null +++ b/tests/custom_field_managers/models.py @@ -0,0 +1,40 @@ +""" +Custom manager for relationship fields. + +Using the ``manager`` and ``reverse_manager`` when creating a ForeignKey, you can +choose custom managers used for direct and reverse relationship. + +Note: You will rarely need to define a custom ``manager`` for a ForeignKey, + execept when you want to filter out the queryset that will be + used to retrieve the related object. + +""" + +from __future__ import unicode_literals + +from django.db import models +from django.utils.encoding import python_2_unicode_compatible + + +class ArticlesManager(models.Manager): + def get_articles_starting_with_a(self): + return self.filter(name__startswith='a') + +class DeletedManager(models.Manager): + def get_queryset(self): + return super(DeletedManager, self).get_queryset().filter(deleted=False) + + +@python_2_unicode_compatible +class Author(models.Model): + name = models.CharField(max_length=30) + deleted = models.BooleanField(default=False) + + +@python_2_unicode_compatible +class Article(models.Model): + name = models.CharField(max_length=30) + author = models.ForeignKey(Author, manager_class=DeletedManager, reverse_manager_class=ArticlesManager, related_name='articles') + + def __str__(self): + return self.name diff --git a/tests/custom_field_managers/tests.py b/tests/custom_field_managers/tests.py new file mode 100644 index 0000000..b2cc65f --- /dev/null +++ b/tests/custom_field_managers/tests.py @@ -0,0 +1,26 @@ +from __future__ import absolute_import + +from django.test import TestCase +from django.utils import six + +from .models import Author, Article, ArticlesManager + + +class CustomFieldsManagerTests(TestCase): + def test_manager(self): + author = Author.objects.create(name='The author') + article = Article.objects.create(name='The article', author=author) + + # Let's see if we have our custom ArticlesManager, for the reverse relationship. + self.assertIsInstance(author.articles, ArticlesManager) + self.assertQuerysetEqual(author.articles.get_articles_starting_with_a(), []) + + self.assertEqual(article.author, author) + + author.deleted = True + author.save() + + article = Article.objects.all()[0] # If we reuse the same article, the author is cached. + + # Because our forward manager will mask a deleted author, this will raise an exception. + self.assertRaises(Author.DoesNotExist, lambda: article.author)