2 from django.db.models import Q, Count
3 from django import template
4 from django.utils.translation import ugettext_lazy as _
5 from django.contrib.auth.models import User
6 from catalogue.models import Chunk, Image, Project
8 register = template.Library()
11 class ChunksList(object):
12 def __init__(self, chunk_qs):
13 self.chunk_qs = chunk_qs.select_related('book', 'book__project', 'stage', 'user')
14 self.book_qs = chunk_qs.values('book_id')
16 def __getitem__(self, key):
17 if isinstance(key, slice):
18 return self.get_slice(key)
19 elif isinstance(key, int):
20 return self.get_slice(slice(key, key+1))[0]
22 raise TypeError('Unsupported list index. Must be a slice or an int.')
25 return self.book_qs.count()
27 def get_slice(self, slice_):
28 book_ids = [x['book_id'] for x in self.book_qs[slice_]]
29 chunk_qs = self.chunk_qs.filter(book__in=book_ids)
33 for chunk in chunk_qs:
34 if chunk.book != book:
36 chunks_list.append(ChoiceChunks(book, [chunk]))
38 chunks_list[-1].chunks.append(chunk)
42 class ChoiceChunks(object):
44 Associates the given chunks iterable for a book.
49 def __init__(self, book, chunks):
54 def foreign_filter(qs, value, filter_field, model, model_field='slug', unset='-'):
56 return qs.filter(**{filter_field: None})
60 obj = model._default_manager.get(**{model_field: value})
61 except model.DoesNotExist:
64 return qs.filter(**{filter_field: obj})
67 def search_filter(qs, value, filter_fields):
70 q = Q(**{"%s__icontains" % filter_fields[0]: value})
71 for field in filter_fields[1:]:
72 q |= Q(**{"%s__icontains" % field: value})
77 ('publishable', _('publishable'), Q(book___new_publishable=True)),
78 ('changed', _('changed'), Q(_changed=True)),
79 ('published', _('published'), Q(book___published=True)),
80 ('unpublished', _('unpublished'), Q(book___published=False)),
81 ('empty', _('empty'), Q(head=None)),
83 _states_options = [s[:2] for s in _states]
84 _states_dict = dict([(s[0], s[2]) for s in _states])
87 def document_list_filter(request, **kwargs):
89 def arg_or_GET(field):
90 return kwargs.get(field, request.GET.get(field))
93 chunks = Chunk.objects.all()
95 chunks = Chunk.visible_objects.all()
97 chunks = chunks.order_by('book__title', 'book', 'number')
99 if not request.user.is_authenticated:
100 chunks = chunks.filter(book__public=True)
102 state = arg_or_GET('status')
103 if state in _states_dict:
104 chunks = chunks.filter(_states_dict[state])
106 chunks = foreign_filter(chunks, arg_or_GET('user'), 'user', User, 'username')
107 chunks = foreign_filter(chunks, arg_or_GET('stage'), 'stage', Chunk.tag_model, 'slug')
108 chunks = search_filter(chunks, arg_or_GET('title'), ['book__title', 'title'])
109 chunks = foreign_filter(chunks, arg_or_GET('project'), 'book__project', Project, 'pk')
113 @register.inclusion_tag('catalogue/book_list/book_list.html', takes_context=True)
114 def book_list(context, user=None):
115 request = context['request']
118 filters = {"user": user}
119 new_context = {"viewed_user": user}
123 "users": User.objects.annotate(
124 count=Count('chunk')).filter(count__gt=0).order_by(
125 '-count', 'last_name', 'first_name'),
126 "other_users": User.objects.annotate(
127 count=Count('chunk')).filter(count=0).order_by(
128 'last_name', 'first_name'),
134 "books": ChunksList(document_list_filter(request, **filters)),
135 "stages": Chunk.tag_model.objects.all(),
136 "states": _states_options,
137 "projects": Project.objects.all(),
145 ('publishable', _('publishable'), Q(_new_publishable=True)),
146 ('changed', _('changed'), Q(_changed=True)),
147 ('published', _('published'), Q(_published=True)),
148 ('unpublished', _('unpublished'), Q(_published=False)),
149 ('empty', _('empty'), Q(head=None)),
151 _image_states_options = [s[:2] for s in _image_states]
152 _image_states_dict = dict([(s[0], s[2]) for s in _image_states])
154 def image_list_filter(request, **kwargs):
156 def arg_or_GET(field):
157 return kwargs.get(field, request.GET.get(field))
159 images = Image.objects.all().select_related('user', 'stage', 'project')
161 if not request.user.is_authenticated:
162 images = images.filter(public=True)
164 state = arg_or_GET('status')
165 if state in _image_states_dict:
166 images = images.filter(_image_states_dict[state])
168 images = foreign_filter(images, arg_or_GET('user'), 'user', User, 'username')
169 images = foreign_filter(images, arg_or_GET('stage'), 'stage', Image.tag_model, 'slug')
170 images = search_filter(images, arg_or_GET('title'), ['title', 'title'])
171 images = foreign_filter(images, arg_or_GET('project'), 'project', Project, 'pk')
175 @register.inclusion_tag('catalogue/image_table.html', takes_context=True)
176 def image_list(context, user=None):
177 request = context['request']
180 filters = {"user": user}
181 new_context = {"viewed_user": user}
185 "users": User.objects.annotate(
186 count=Count('image')).filter(count__gt=0).order_by(
187 '-count', 'last_name', 'first_name'),
188 "other_users": User.objects.annotate(
189 count=Count('image')).filter(count=0).order_by(
190 'last_name', 'first_name'),
196 "objects": image_list_filter(request, **filters),
197 "stages": Image.tag_model.objects.all(),
198 "states": _image_states_options,
199 "projects": Project.objects.all(),