I was wondering if it was possible (and, if so, how) to chain together
multiple managers to produce a query set that is affected by both of
the individual managers. I'll explain the specific example that I'm
working on:
I have multiple abstract model classes that I use to provide small,
specific functionality to other models. Two of these models are a
DeleteMixin and a GlobalMixin.
The DeleteMixin is defined as such:
class DeleteMixin(models.Model):
deleted = models.BooleanField(default=False)
objects = DeleteManager()
class Meta:
abstract = True
def delete(self):
self.deleted = True
self.save()
Basically it provides a pseudo-delete (the deleted flag) instead of
actually deleting the object.
The GlobalMixin is defined as such:
class GlobalMixin(models.Model):
is_global = models.BooleanField(default=True)
objects = GlobalManager()
class Meta:
abstract = True
It allows any object to be defined as either a global object or a
private object (such as a public/private blog post).
Both of these have their own managers that affect the queryset that is
returned. My DeleteManager filters the queryset to only return results
that have the deleted flag set to False, while the GlobalManager
filters the queryset to only return results that are marked as global.
Here is the declaration for both:
class DeleteManager(models.Manager):
def get_query_set(self):
return super(DeleteManager, self).get_query_set().filter
(deleted=False)
class GlobalManager(models.Manager):
def globals(self):
return self.get_query_set().filter(is_global=1)
The desired functionality would be to have a model extend both of
these abstract models and grant the ability to only return the results
that are both non-deleted and global. I ran a test case on a model
with 4 instances: one was global and non-deleted, one was global and
deleted, one was non-global and non-deleted, and one was non-global
and deleted. If I try to get result sets as such: SomeModel.objects.all
(), I get instance 1 and 3 (the two non-deleted ones - great!). If I
try SomeModel.objects.globals(), I get an error that DeleteManager
doesn't have a globals (this is assuming my model declaration is as
such: SomeModel(DeleteMixin, GlobalMixin). If I reverse the order, I
don't get the error, but it doesn't filter out the deleted ones). If I
change GlobalMixin to attach GlobalManager to globals instead of
objects (so the new command would be SomeModel.globals.globals()), I
get instances 1 and 2 (the two globals), while my intended result
would be to only get instance 1 (the global, non-deleted one).
I wasn't sure if anyone had run into any situation similar to this and
had come to a result. Either a way to make it work in my current
thinking or a re-work that provides the functionality I'm after would
be very much appreciated. I know this post has been a little long-
winded. If any more explanation is needed, I would be glad to provide
it.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to
django-users+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en
-~----------~----~----~----~------~----~------~--~---
