Ticket #14891: patch.diff

django/db/models/fields/related.py

@@ -251 +251 @@
     # 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 +379 @@
     # 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 +401 @@
     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 +951 @@
                 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 +1120 @@
 
     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)
 

new file tests/custom_field_managers/models.py

@@ +1 @@
+"""
+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

new file tests/custom_field_managers/tests.py

@@ +1 @@
+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)