Personnalisé QuerySet et Gestionnaire sans casser SEC?

Django a changé! Avant d'utiliser le code dans cette réponse, qui a été écrit en 2009, assurez-vous de vérifier le reste des réponses et de la documentation de Django pour voir si il y a une solution plus appropriée.

---

La façon dont je l'ai mis en place c'est par l'ajout de la réelle get_active_for_account comme une méthode personnalisée QuerySet. Ensuite, pour le faire fonctionner hors de l'manager, vous pouvez simplement piège de la __getattr__ et le retourner par conséquent

Pour faire de ce modèle réutilisable, j'ai extrait le Manager bits pour un autre modèle de manager:

custom_queryset/models.py

from django.db import models
from django.db.models.query import QuerySet

class CustomQuerySetManager(models.Manager):
    """A re-usable Manager to access a custom QuerySet"""
    def __getattr__(self, attr, *args):
        try:
            return getattr(self.__class__, attr, *args)
        except AttributeError:
            # don't delegate internal methods to the queryset
            if attr.startswith('__') and attr.endswith('__'):
                raise
            return getattr(self.get_query_set(), attr, *args)

    def get_query_set(self):
        return self.model.QuerySet(self.model, using=self._db)

Une fois que vous avez que, sur vos modèles, tout ce que vous devez faire est de définir un QuerySet comme une coutume intérieur de la classe et de définir le gestionnaire personnalisé de votre manager:

your_app/models.py

from custom_queryset.models import CustomQuerySetManager
from django.db.models.query import QuerySet

class Inquiry(models.Model):
    objects = CustomQuerySetManager()

    class QuerySet(QuerySet):
        def active_for_account(self, account, *args, **kwargs):
            return self.filter(account=account, deleted=False, *args, **kwargs)

Avec ce modèle, aucun de ces travaux:

>>> Inquiry.objects.active_for_account(user)
>>> Inquiry.objects.all().active_for_account(user)
>>> Inquiry.objects.filter(first_name='John').active_for_account(user)

UPD si vous l'utilisez avec des personnalisés de l'utilisateur(AbstractUser), vous avez besoin de changer

de

class CustomQuerySetManager(models.Manager):

à

from django.contrib.auth.models import UserManager

class CustomQuerySetManager(UserManager):
    ***

Vous pouvez fournir les méthodes sur le gestionnaire et le queryset à l'aide d'un mixin. Voir la technique suivante:

http://hunterford.me/django-custom-model-manager-chaining/

Cela permet aussi d'éviter l'utilisation d'un __getattr__() approche.

from django.db.models.query import QuerySet

class PostMixin(object):
    def by_author(self, user):
        return self.filter(user=user)

    def published(self):
        return self.filter(published__lte=datetime.now())

class PostQuerySet(QuerySet, PostMixin):
    pass

class PostManager(models.Manager, PostMixin):
    def get_query_set(self):
        return PostQuerySet(self.model, using=self._db)

Vous pouvez maintenant utiliser le from_queryset() méthode sur vous manager pour modifier sa base de Queryset.

Cela vous permet de définir votre Queryset méthodes et votre gestionnaire de méthodes qu'une seule fois

de la documentation

Pour une utilisation avancée, vous pourriez vouloir à la fois une coutume Gestionnaire et une coutume QuerySet. Vous pouvez le faire en appelant le Gestionnaire.from_queryset() qui retourne une sous-classe de votre Gestionnaire de base avec une copie de la coutume QuerySet méthodes:

class InqueryQueryset(models.Queryset):
    def custom_method(self):
        """ available on all default querysets"""

class BaseMyInquiryManager(models.Manager):
    def for_user(self, user):
        return self.get_query_set().filter(
                    Q(assigned_to_user=user) |
                    Q(assigned_to_group__in=user.groups.all())
                )

MyInquiryManager = BaseInquiryManager.from_queryset(InquiryQueryset)

class Inquiry(models.Model):   
    ts = models.DateTimeField(auto_now_add=True)
    status = models.ForeignKey(InquiryStatus)
    assigned_to_user = models.ForeignKey(User, blank=True, null=True)
    assigned_to_group = models.ForeignKey(Group, blank=True, null=True)
    objects = MyInquiryManager()