1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
"""
Tagging related views.
"""
from django.core.exceptions import ImproperlyConfigured
from django.http import Http404
from django.utils.translation import gettext as _
from django.views.generic.list import ListView
from tagging.models import Tag
from tagging.models import TaggedItem
from tagging.utils import get_queryset_and_model
from tagging.utils import get_tag
class TaggedObjectList(ListView):
"""
A thin wrapper around
``django.views.generic.list.ListView`` which creates a
``QuerySet`` containing instances of the given queryset or model
tagged with the given tag.
In addition to the context variables set up by ``object_list``, a
``tag`` context variable will contain the ``Tag`` instance for the
tag.
If ``related_tags`` is ``True``, a ``related_tags`` context variable
will contain tags related to the given tag for the given model.
Additionally, if ``related_tag_counts`` is ``True``, each related
tag will have a ``count`` attribute indicating the number of items
which have it in addition to the given tag.
"""
tag = None
related_tags = False
related_tag_counts = True
def get_tag(self):
if self.tag is None:
try:
self.tag = self.kwargs.pop('tag')
except KeyError:
raise AttributeError(
_('TaggedObjectList must be called with a tag.'))
tag_instance = get_tag(self.tag)
if tag_instance is None:
raise Http404(_('No Tag found matching "%s".') % self.tag)
return tag_instance
def get_queryset_or_model(self):
if self.queryset is not None:
return self.queryset
elif self.model is not None:
return self.model
else:
raise ImproperlyConfigured(
"%(cls)s is missing a QuerySet. Define "
"%(cls)s.model, %(cls)s.queryset, or override "
"%(cls)s.get_queryset_or_model()." % {
'cls': self.__class__.__name__
}
)
def get_queryset(self):
self.queryset_or_model = self.get_queryset_or_model()
self.tag_instance = self.get_tag()
return TaggedItem.objects.get_by_model(
self.queryset_or_model, self.tag_instance)
def get_context_data(self, **kwargs):
context = super(TaggedObjectList, self).get_context_data(**kwargs)
context['tag'] = self.tag_instance
if self.related_tags:
queryset, model = get_queryset_and_model(self.queryset_or_model)
context['related_tags'] = Tag.objects.related_for_model(
self.tag_instance, model, counts=self.related_tag_counts)
return context
|
