def search(request):
from sphinxapi import SphinxClient, SPH_MATCH_EXTENDED, SPH_SORT_RELEVANCE
term = request.GET.get('term', '')
category = None
args = [u'term=%s'%term]
template_name = 'board/search.html'
if term:
sphinx = SphinxClient()
sphinx.SetServer(settings.SPHINX_SERVER, settings.SPHINX_PORT)
sphinx.SetMatchMode(SPH_MATCH_EXTENDED)
sphinx.SetSortMode(SPH_SORT_RELEVANCE)
cid = request.GET.get('c')
if cid:
try:
cid = int(cid)
except TypeError:
raise Http404
category = get_object_or_404(Category, cid)
if category:
sphinx.SetFilter('category_id', [category])
args.append(u'c=%s'%cid)
user_settings = get_user_settings(request.user)
try:
page = int(request.GET.get('page', '1'))
if page < 1:
raise Http404
except ValueError:
raise Http404
#sphinx.SetLimits(page * user_settings.ppp, user_settings.ppp)
if request.GET.get('adv_submit.x'):
template_name='board/advanced_search.html'
u = User.objects.filter(username=term)
if u:
q = QuerySetPaginator(Post.objects.filter(user=u),
user_settings.ppp)
else:
q = Paginator([], 1).page(1)
else:
result = sphinx.Query(u'@@relaxed %s'%term)
if not result.has_key('total_found'):
template_name = 'board/search_unavailable.html'
pages = result.get('total_found', 0) / user_settings.ppp
if pages > 0 and page > pages:
raise Http404
ids = [m['id'] for m in result.get('matches', [])]
q = QuerySetPaginator(Post.view_manager.filter(id__in=ids),
user_settings.ppp)
q = get_page(request.GET.get('page', 1), q)
else:
q = Paginator([], 1).page(1)
return render_to_response(template_name, {
'result': q,
'term': term,
'category': category,
'args': u'&'.join(['']+args),
}, context_instance=RequestContext(request, processors=extra_processors))
def topic(request, username, slug=''):
user = get_object_or_404(User, username=username)
if not slug:
last10 = Topic.objects.filter(author=user).order_by('-created')[:10]
subs = user.attrs.get('beats')
if subs:
subs = Topic.objects.filter(
author__pk__in=subs).order_by('-created')[:10]
return render_to_response('homepage.html', {
'last10': last10,
'subs': subs,
'object': user,
},
context_instance=RequestContext(request))
if slug not in ['posts', 'beats']:
topic = get_object_or_404(Topic, slug=slug, author=user)
return render_to_response('topic.html', {
'post': topic,
},
context_instance=RequestContext(request))
if slug == 'posts':
q = QuerySetPaginator(
Topic.objects.filter(author=user).order_by('-created'),
RESULTS_ON_PAGE,
orphans=5,
)
title = u"%s %s" % (_("All torrents of"), user.username)
else: #beats
q = user.attrs.get('beats', [])
if q:
q = QuerySetPaginator(
Topic.objects.filter(
author__pk__in=result).order_by('-created'),
RESULTS_ON_PAGE,
orphans=5,
)
else:
q = Paginator([], 1)
title = u"%s %s" % (_("Subscription of"), user.username)
q = get_page(request.GET.get('page', 0), q)
return render_to_response('homepage.html', {
'result': q,
'object': user,
'title': title,
},
context_instance=RequestContext(request))
def search_results(request, service_id, search_terms, page_number=1):
results = DownloadLink.objects.filter(hidden=False)
term_list = search_terms.split('+')
for term in term_list:
results = results.filter(name__icontains=term)
try:
service = DownloadService.objects.get(id=service_id)
results = results.filter(service=service)
except:
service = None
paginator = QuerySetPaginator(results, 25)
page = paginator.page(page_number)
return render_response(
request, 'style2/search_results.html', '', {
'search_terms': search_terms,
'service': service,
'page': page,
'paginator': paginator,
'term_list': term_list,
})
def paginate_queryset_for_request(request, qset, paginate_by):
""" returns appropriate page for view. Page number should
be set in GET variable 'p', if not set first page is returned.
"""
item_number_mapping = {}
for i, c in enumerate(qset):
item_number_mapping[c._get_pk_val()] = i + 1
paginator = QuerySetPaginator(qset, paginate_by)
page_no = request.GET.get('p', paginator.page_range[0])
try:
page_no = int(page_no)
if not page_no in paginator.page_range:
page_no = paginator.page_range[0]
except Exception:
page_no = paginator.page_range[0]
context = {}
page = paginator.page(page_no)
objs = page.object_list
context['object_list'] = objs
context.update({
'is_paginated': paginator.num_pages > 1,
'results_per_page': paginate_by,
'page': page,
'item_number_mapping': item_number_mapping,
})
return context
def detail(request, context):
""" Custom object detail function that adds a QuestionForm to the context. """
interview = context['object']
page_no = get_page_no(request)
qset = interview.get_questions()
paginator = QuerySetPaginator(qset,
interviews_settings.PAGINATION_PER_PAGE)
if page_no > paginator.num_pages or page_no < 1:
raise Http404
page = paginator.page(page_no)
interviewees = interview.get_interviewees(request.user)
context.update({
'interviewees': interviewees,
'is_paginated': paginator.num_pages > 1,
'results_per_page': interviews_settings.PAGINATION_PER_PAGE,
'page': page,
'form': QuestionForm(request),
'questions': page.object_list,
})
return render_to_response(get_templates_from_placement(
'object.html', context['placement']),
context,
context_instance=RequestContext(request))
def series_and_issue(request, series_name, issue_nr, sort=ORDER_ALPHA):
""" Looks for issue_nr in series_name """
things = Issue.objects.filter(series__name__exact = series_name) \
.filter(number__exact = issue_nr)
if things.count() == 1: # if one display the issue
return HttpResponseRedirect(urlresolvers.reverse(issue,
kwargs={ 'issue_id': things[0].id }))
else: # if more or none use issue_list.html from search
p = QuerySetPaginator(things, 100)
page_num = 1
if (request.GET.has_key('page')):
page_num = int(request.GET['page'])
page = p.page(page_num)
context = {
'items' : things,
'item_name' : 'issue',
'plural_suffix' : 's',
'heading' : series_name + ' #' + issue_nr,
'style' : 'default',
}
if 'style' in request.GET:
context['style'] = request.GET['style']
return paginate_response(
request, things, 'gcd/search/issue_list.html', context)
def search(request):
import re
from pysolr import Solr
from stats.models import DailySearch
from settings import SOLR_URL
def _fail(query):
# phrase is not changed, query is normalized phrase
return render_to_response('search_results.html', {
'result': [],
'query': query,
'phrase': query,
},
context_instance=RequestContext(request))
phrase = request.GET.get('phrase')
try:
conn = Solr(SOLR_URL)
except:
return _fail(phrase)
result = []
if not phrase:
raise Http404("Malformed request.")
q = phrase
if phrase.startswith('*') or phrase.startswith('?'):
q = phrase[1:]
q = q.strip()
q = re.sub('[' + '\[<>@\]' + ']', '', q)
q = re.sub('`', '"', q)
q = re.sub('\s*:', ':', q)
q = re.sub(
'(?<!author)(?<!title)(?<!text)(?<!file)(?<!tag)(?<!artist)(?<!album)(?<!year)(?<!company)(?<!created):',
' ', q)
if not q:
return _fail(phrase)
results = conn.search(q)
if not results:
return _fail(q)
ids = [i['id'] for i in results]
result = QuerySetPaginator(Topic.objects.filter(pk__in=ids),
RESULTS_ON_PAGE,
orphans=5)
if result.num_pages == 0:
return _fail(q)
p = DailySearch.objects.create(phrase=q.strip())
page = request.GET.get('page', 1)
try:
page = int(page)
r = result.page(page)
except (InvalidPage, ValueError):
raise Http404("No such page")
return render_to_response('search_results.html', {
'result': r,
'query': q,
'phrase': phrase,
'page': int(page),
'title': phrase,
},
context_instance=RequestContext(request))
def browse2(request, page_number=1):
links = DownloadLink.objects.filter(hidden=False)
paginator = QuerySetPaginator(links, 25)
page = paginator.page(page_number)
return render_response(request, 'style2/link_browse_json.html', '', {
'page': page,
'paginator': paginator,
})
def link_topic(request, topic_id, page_number=1):
topic = get_object_or_404(DownloadTopics, pk=topic_id)
links = DownloadLink.objects.filter(hidden=False, from_topic=topic)
paginator = QuerySetPaginator(links, 26)
page = paginator.page(page_number)
return render_response(request, 'style2/link_topic.html', '', {
'topic': topic,
'page': page,
'paginator': paginator,
})
def surveygroup_list(request):
page_no = int(request.GET.get('page', 1))
surveygroup_list = SurveyGroup.objects.all()
p = QuerySetPaginator(surveygroup_list, 50)
page = p.page(page_no)
return render_to_response('django_surveys/surveygroup_list.html',
locals(),
context_instance=RequestContext(request))
def thread(request, thread_id):
try:
thr = Thread.view_manager.get(pk=thread_id)
except Thread.DoesNotExist:
raise Http404
if not thr.category.can_read(request.user):
raise PermissionError
render_dict = {}
if request.user.is_authenticated():
render_dict.update({"watched": WatchList.objects.filter(user=request.user, thread=thr).count() != 0})
if request.POST:
if not thr.category.can_post(request.user):
raise PermissionError
postform = PostForm(request.POST)
if postform.is_valid():
postobj = Post(thread = thr,
user = request.user,
text = postform.cleaned_data['post'],
)
postobj.save() # this needs to happen before many-to-many private is assigned
if len(postform.cleaned_data['private']) > 0:
_log.debug('thread(): new post private = %s' % postform.cleaned_data['private'])
postobj.private = postform.cleaned_data['private']
postobj.is_private = True
postobj.save()
postobj.notify()
return HttpResponseRedirect(reverse('board_locate_post',
args=(postobj.id,)))
else:
postform = PostForm()
# this must come after the post so new messages show up
post_list = Post.view_manager.posts_for_thread(thread_id, request.user)
user_settings = get_user_settings(request.user)
if user_settings.reverse_posts:
post_list = post_list.order_by('-odate')
post_list = QuerySetPaginator(post_list, user_settings.ppp)
render_dict.update({
'result': get_page(request.GET.get('page', 1), post_list),
'thr': thr,
'postform': postform,
'category': thr.category,
})
return render_to_response('board/thread.html',
render_dict,
context_instance=RequestContext(request, processors=extra_processors))
def survey_list(request, surveygroup_id):
surveygroup = get_object_or_404(SurveyGroup, pk=surveygroup_id)
survey_list = Survey.objects.filter(survey_group__id=surveygroup_id)
page_no = int(request.GET.get('page', 1))
p = QuerySetPaginator(survey_list, 50)
page = p.page(page_no)
return render_to_response('django_surveys/survey_list.html',
locals(),
context_instance=RequestContext(request))
def service_listing(request, service_id, page_number=1):
service = get_object_or_404(DownloadService, pk=service_id)
links = service.downloadlink_set.filter(hidden=False)
paginator = QuerySetPaginator(links, 25)
page = paginator.page(page_number)
return render_response(request, 'style2/service_view.html', '/service/%s/' % service_id,
{
'service': service,
'page': page,
'paginator': paginator,
})
def list(self, request, queryset, page=None):
"""
Renders a list of model objects to HttpResponse.
"""
template_name = '%s/%s_list.html' % (self.template_dir,
queryset.model._meta.module_name)
if self.paginate_by:
paginator = QuerySetPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.page(page).object_list
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
raise Http404
current_page = paginator.page(page)
c = RequestContext(
request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': paginator.num_pages > 1,
'results_per_page': self.paginate_by,
'has_next': current_page.has_next(),
'has_previous': current_page.has_previous(),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': current_page.end_index(),
'first_on_page': current_page.start_index(),
'pages': paginator.num_pages,
'hits': paginator.count,
}, self.context_processors)
else:
object_list = queryset
c = RequestContext(
request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': False
}, self.context_processors)
if not self.allow_empty and len(queryset) == 0:
raise Http404
# Hide unexposed fields
for obj in object_list:
self._hide_unexposed_fields(obj, self.expose_fields)
c.update(self.extra_context)
t = self.template_loader.get_template(template_name)
return HttpResponse(t.render(c), mimetype=self.mimetype)
def thread_index(request):
if request.user.is_authenticated():
# filter on user prefs
thread_list = Thread.view_manager.get_user_query_set(request.user)
else:
thread_list = Thread.view_manager.get_query_set()
user_settings = get_user_settings(request.user)
thread_list = QuerySetPaginator(
filter(lambda t: t.category.can_view(request.user), thread_list),
user_settings.tpp
)
render_dict = {
'title': _("Recent Discussions"),
'result': get_page(request.GET.get('page', 1), thread_list),
'ppp': user_settings.tpp,
}
return render_to_response('board/thread_index.html', render_dict,
context_instance=RequestContext(request, processors=extra_processors))
def list(self, request, queryset, page=None):
"""
Renders a list of model objects to HttpResponse.
"""
if self.paginate_by:
paginator = QuerySetPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.page(page).object_list
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
return self.error(request, 404)
else:
object_list = list(queryset)
return HttpResponse(self.render(object_list), self.mimetype)
def topic_list(request, slug=None):
q = Topic.objects.filter(Q(section=slug) | Q(subcat=slug), approved=True)
order = request.GET.get('order')
args = ""
if order in ['d', 'L', 'l', 'S', 's', 'B', 'b']:
q = _sort_by(order, q)
args = "?order=%s" % order
q = get_page(
request.GET.get('page', 0),
QuerySetPaginator(q, RESULTS_ON_PAGE, orphans=ORPHANS),
)
return render_to_response('sections.html', {
'result': q,
'slug': slug,
'args': args,
'order': order,
},
context_instance=RequestContext(request))
def get_results(self, request):
paginator = QuerySetPaginator(self.query_set,
self.lookup_opts.admin.list_per_page)
# Get the number of objects, with admin filters applied.
try:
result_count = paginator.count
# Naked except! Because we don't have any other way of validating
# "params". They might be invalid if the keyword arguments are
# incorrect, or if the values are not in the correct type (which would
# result in a database error).
except:
raise IncorrectLookupParameters
# Get the total number of objects, with no admin filters applied.
# Perform a slight optimization: Check to see whether any filters were
# given. If not, use paginator.hits to calculate the number of objects,
# because we've already done paginator.hits and the value is cached.
if isinstance(self.query_set._filters,
models.Q) and not self.query_set._filters.kwargs:
full_result_count = result_count
else:
full_result_count = self.manager.count()
can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED
multi_page = result_count > self.lookup_opts.admin.list_per_page
# Get the list of objects to display on this page.
if (self.show_all and can_show_all) or not multi_page:
result_list = list(self.query_set)
else:
try:
result_list = paginator.page(self.page_num + 1).object_list
except InvalidPage:
result_list = ()
self.result_count = result_count
self.full_result_count = full_result_count
self.result_list = result_list
self.can_show_all = can_show_all
self.multi_page = multi_page
self.paginator = paginator
def category_thread_index(request, cat_id):
try:
cat = Category.objects.get(pk=cat_id)
if not cat.can_read(request.user):
raise PermissionError
user_settings = get_user_settings(request.user)
thread_list = QuerySetPaginator(
Thread.view_manager.get_category(cat_id),
user_settings.tpp
)
render_dict = ({'title': ''.join((_("Category: "), cat.label)),
'category': cat,
'result': get_page(request.GET.get('page', 1), thread_list),
'ppp': user_settings.tpp,
})
except Category.DoesNotExist:
raise Http404
return render_to_response('board/thread_index.html',
render_dict,
context_instance=RequestContext(request, processors=extra_processors))
def render(request, template, dict={}):
r = Result.objects.all().order_by('-run_date', '-upload_date')
p = QuerySetPaginator(r, 50)
try:
page_num = int(request.GET['p'])
if page_num < 1:
page_num = 1
elif page_num > p.num_pages:
page_num = p.num_pages
except:
page_num = 1
page = p.page(page_num)
dict['p'] = p
dict['page'] = page
dict['results'] = result_list(page.object_list)
dict['r'] = result_list(r)
return render_to_response(template, dict)
def messages(request, action, page=0):
if action not in ['sent', 'received']: raise Http404
from users.models import PersonalMessage
from django.core.paginator import QuerySetPaginator, InvalidPage
from utils import get_page
render_dict = {}
if action == 'sent':
q = PersonalMessage.objects.filter(rply=request.user).order_by('-date')
render_dict.update({'title': _("Sent messages"), 'page_id': 'sent'})
else:
q = PersonalMessage.objects.filter(rcpt=request.user).order_by('-date')
render_dict.update({
'title': _("Received messages"),
'page_id': 'received'
})
q = get_page(
request.GET.get('page', 0),
QuerySetPaginator(q,
settings.RESULTS_ON_PAGE,
orphans=settings.ORPHANS))
render_dict.update({'result': q})
return render_to_response('users/messages.html', render_dict)
def list(request, page=0):
comments = FreeComment.objects.filter(content_type=Photo,
approved=True,
is_public=True)
paginator = QuerySetPaginator(comments, 25, allow_empty_first_page=True)
if not page:
page = request.GET.get('page', 1)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404
try:
page_obj = paginator.page(page_number)
except InvalidPage:
raise Http404
return render(request=request,
template_name='photos/comment_list.html',
payload={
'comments': comments,
'is_paginated': page_obj.has_other_pages(),
'results_per_page': paginator.per_page,
'has_next': page_obj.has_next(),
'has_previous': page_obj.has_previous(),
'page': page_obj.number,
'next': page_obj.next_page_number(),
'previous': page_obj.previous_page_number(),
'first_on_page': page_obj.start_index(),
'last_on_page': page_obj.end_index(),
'pages': paginator.num_pages,
'hits': paginator.count,
'page_range': paginator.page_range,
})
def tags(request, tag=None):
from tagging.models import TaggedItem
result = TaggedItem.objects.get_by_model(
Topic, tag).filter(approved=True).order_by('-created')
if not result:
raise Http404("No such tag")
related_tags = []
for item in result:
for t in item.tags:
if t not in related_tags and t.name != tag:
related_tags.append(t)
q = get_page(
request.GET.get('page', 0),
QuerySetPaginator(result, RESULTS_ON_PAGE, orphans=5),
)
return render_to_response(
'tags.html', {
'result': q,
'related_tags': related_tags,
'tag': tag,
'title': u"%s %s" % (_("tag"), tag)
})
def detail(request, gallery_slug, page=0):
gallery = get_object_or_404(Gallery, slug__iexact=gallery_slug)
photos = Photo.objects.filter(gallery=gallery)
paginator = QuerySetPaginator(photos, 25, allow_empty_first_page=True)
if not page:
page = request.GET.get('page', 1)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404
try:
page_obj = paginator.page(page_number)
except InvalidPage:
raise Http404
return render(request, 'photos/gallery_detail.html', {
'gallery': gallery,
'photos': photos,
'is_paginated': page_obj.has_other_pages(),
'results_per_page': paginator.per_page,
'has_next': page_obj.has_next(),
'has_previous': page_obj.has_previous(),
'page': page_obj.number,
'next': page_obj.next_page_number(),
'previous': page_obj.previous_page_number(),
'first_on_page': page_obj.start_index(),
'last_on_page': page_obj.end_index(),
'pages': paginator.num_pages,
'hits': paginator.count,
'page_range': paginator.page_range,
})
def test_querysetpaginator_deprecation(self):
msg = 'The QuerySetPaginator alias of Paginator is deprecated.'
with self.assertWarnsMessage(RemovedInDjango31Warning, msg) as cm:
QuerySetPaginator([], 1)
self.assertEqual(cm.filename, __file__)
def precompute_objects(self):
"""
Builds the queryset and stores the list of objects for use in
rendering the datagrid.
"""
query = self.queryset
use_select_related = False
# Generate the actual list of fields we'll be sorting by
sort_list = []
for sort_item in self.sort_list:
if sort_item[0] == "-":
base_sort_item = sort_item[1:]
prefix = "-"
else:
base_sort_item = sort_item
prefix = ""
if sort_item and base_sort_item in self.db_field_map:
db_field = self.db_field_map[base_sort_item]
sort_list.append(prefix + db_field)
# Lookups spanning tables require that we query from those
# tables. In order to keep things simple, we'll just use
# select_related so that we don't have to figure out the
# table relationships. We only do this if we have a lookup
# spanning tables.
if '.' in db_field:
use_select_related = True
if sort_list:
query = query.order_by(*sort_list)
self.paginator = QuerySetPaginator(query.distinct(), self.paginate_by,
self.paginate_orphans)
page_num = self.request.GET.get('page', 1)
# Accept either "last" or a valid page number.
if page_num == "last":
page_num = self.paginator.num_pages
try:
self.page = self.paginator.page(page_num)
except InvalidPage:
raise Http404
self.id_list = []
if self.optimize_sorts and len(sort_list) > 0:
# This can be slow when sorting by multiple columns. If we
# have multiple items in the sort list, we'll request just the
# IDs and then fetch the actual details from that.
self.id_list = list(
self.page.object_list.values_list('pk', flat=True))
# Make sure to unset the order. We can't meaningfully order these
# results in the query, as what we really want is to keep it in
# the order specified in id_list, and we certainly don't want
# the database to do any special ordering (possibly slowing things
# down). We'll set the order properly in a minute.
self.page.object_list = self.post_process_queryset(
self.queryset.model.objects.filter(
pk__in=self.id_list).order_by())
if use_select_related:
self.page.object_list = \
self.page.object_list.select_related(depth=1)
if self.id_list:
# The database will give us the items in a more or less random
# order, since it doesn't know to keep it in the order provided by
# the ID list. This will place the results back in the order we
# expect.
index = dict([(id, pos) for (pos, id) in enumerate(self.id_list)])
object_list = [None] * len(self.id_list)
for obj in list(self.page.object_list):
object_list[index[obj.pk]] = obj
else:
# Grab the whole list at once. We know it won't be too large,
# and it will prevent one query per row.
object_list = list(self.page.object_list)
for column in self.columns:
column.collect_objects(object_list)
self.rows = [{
'object':
obj,
'cells': [column.render_cell(obj) for column in self.columns]
} for obj in object_list if obj is not None]
def precompute_objects(self):
"""
Builds the queryset and stores the list of objects for use in
rendering the datagrid.
Just like the method in the superclass,
except we use self.depth as the depth for select_related
"""
query = self.queryset
use_select_related = False
# Generate the actual list of fields we'll be sorting by
sort_list = []
for sort_item in self.sort_list:
if sort_item[0] == "-":
base_sort_item = sort_item[1:]
prefix = "-"
else:
base_sort_item = sort_item
prefix = ""
if sort_item and base_sort_item in self.db_field_map:
db_field = self.db_field_map[base_sort_item]
sort_list.append(prefix + db_field)
# Lookups spanning tables require that we query from those
# tables. In order to keep things simple, we'll just use
# select_related so that we don't have to figure out the
# table relationships. We only do this if we have a lookup
# spanning tables.
if '.' in db_field:
use_select_related = True
if sort_list:
query = query.order_by(*sort_list)
if use_select_related:
query = query.select_related(depth=self.depth)
self.paginator = QuerySetPaginator(query, self.paginate_by,
self.paginate_orphans)
page_num = self.request.GET.get('page', 1)
# Accept either "last" or a valid page number.
if page_num == "last":
page_num = self.paginator.num_pages
try:
self.page = self.paginator.page(page_num)
except InvalidPage:
raise Http404
self.rows = []
for obj in self.page.object_list:
self.rows.append({
'object':
obj,
'cells': [column.render_cell(obj) for column in self.columns]
})
def object_list(request,
queryset,
paginate_by=None,
page=None,
allow_empty=True,
template_name=None,
template_loader=loader,
extra_context=None,
context_processors=None,
template_object_name='object',
mimetype=None):
"""
Generic list of objects.
Templates: ``<app_label>/<model_name>_list.html``
Context:
object_list
list of objects
is_paginated
are the results paginated?
results_per_page
number of objects per page (if paginated)
has_next
is there a next page?
has_previous
is there a prev page?
page
the current page
next
the next page
previous
the previous page
pages
number of pages, total
hits
number of objects, total
last_on_page
the result number of the last of object in the
object_list (1-indexed)
first_on_page
the result number of the first object in the
object_list (1-indexed)
page_range:
A list of the page numbers (1-indexed).
"""
if extra_context is None: extra_context = {}
queryset = queryset._clone()
if paginate_by:
paginator = QuerySetPaginator(queryset,
paginate_by,
allow_empty_first_page=allow_empty)
if not page:
page = request.GET.get('page', 1)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
# Page is not 'last', nor can it be converted to an int.
raise Http404
try:
page_obj = paginator.page(page_number)
except InvalidPage:
raise Http404
c = RequestContext(
request,
{
'%s_list' % template_object_name: page_obj.object_list,
'paginator': paginator,
'page_obj': page_obj,
# Legacy template context stuff. New templates should use page_obj
# to access this instead.
'is_paginated': page_obj.has_other_pages(),
'results_per_page': paginator.per_page,
'has_next': page_obj.has_next(),
'has_previous': page_obj.has_previous(),
'page': page_obj.number,
'next': page_obj.next_page_number(),
'previous': page_obj.previous_page_number(),
'first_on_page': page_obj.start_index(),
'last_on_page': page_obj.end_index(),
'pages': paginator.num_pages,
'hits': paginator.count,
'page_range': paginator.page_range,
},
context_processors)
else:
c = RequestContext(
request, {
'%s_list' % template_object_name: queryset,
'paginator': None,
'page_obj': None,
'is_paginated': False,
}, context_processors)
if not allow_empty and len(queryset) == 0:
raise Http404
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
if not template_name:
model = queryset.model
template_name = "%s/%s_list.html" % (model._meta.app_label,
model._meta.object_name.lower())
t = template_loader.get_template(template_name)
return HttpResponse(t.render(c), mimetype=mimetype)
def json_browse(request, page_number=1):
paginator = QuerySetPaginator(DownloadLink.objects.filter(hidden=False), 4)
page = paginator.page(page_number)
from time import sleep
return json_paginator_response(page)
def search(request):
if request.GET.has_key('format') and request.GET['format']:
ref = request.META['HTTP_REFERER']
start = ref.index('?')
q_string = ref[start:]
target = "/export/" + request.GET['format'] + "/" + q_string
return HttpResponseRedirect(target)
else:
form = AdvancedSearchForm(request.GET)
if form.is_valid():
msg = None
do_search = False
for item in form.cleaned_data.values():
if item and item not in [
'Last Name, First', 'Ex: Blood', 'Ex: melanoma', '0',
'BLANK'
]:
do_search = True
if do_search:
# results is a QuerySet
results = search_all(form.cleaned_data)
# print results
result_count = len(results)
# print result_count
search_phrase, just_author = build_search_phrase(form)
if results:
paginator = QuerySetPaginator(results, 200)
# print paginator
try:
result_count = paginator.count
# print "Result Count: ", result_count
except TypeError:
# result_count = 0
if just_author:
msg = u'Your search for <em>%s</em> returned no results. If this is an MSK author, please contact <a href="/comments/" alt="Synapse Comments" title="Synapse Comments">the Synapse Administrators</a>.' % search_phrase
else:
msg = u'Your search for <em>%s</em> returned no results. Please broaden your search and try again.' % search_phrase
form = AdvancedSearchForm()
return render_to_response(
'synapse/search.html', {
'form': form,
'show_dmt': False,
'is_internal': is_internal(request),
'msg': msg
})
# full_uri = "/documents/search/?"
#
# full_uri = full_uri + request.GET.urlencode()
# full_uri = request.path + '?' + request.GET.urlencode()
# TODO: rip request.GET apart, rebuild new URL without the extraneous page terms
new_url = {}
if request.GET.has_key('author'):
if request.GET['author'] != 'Last Name, First':
new_url['author'] = request.GET['author']
if request.GET.has_key('journal'):
if request.GET['journal'] != '':
new_url['journal'] = request.GET['journal']
if request.GET.has_key('year_start'):
if request.GET['year_start'] != 'BLANK':
new_url['year_start'] = request.GET['year_start']
if request.GET.has_key('year_end'):
if request.GET['year_end'] != 'BLANK':
new_url['year_end'] = request.GET['year_end']
if request.GET.has_key('keywords'):
if request.GET['keywords'] != '':
new_url['keywords'] = request.GET['keywords']
if request.GET.has_key('doc_type'):
new_url['doc_type'] = form.cleaned_data['doc_type']
results_page = None
page = 0
if request.GET.has_key('page'):
page = int(request.GET['page'])
else:
page = 1
results_page = paginator.page(page)
previous = 0
next = 0
if page > 0:
previous = results_page.number - 1
next = results_page.number + 1
# if request.GET.has_key('page'):
# if request.GET['page'] != '':
# new_url['page'] = request.GET['page']
# print "new_url: ", urlencode(new_url, doseq=True)
full_uri = '?' + urlencode(new_url, doseq=True)
context = {
'data': search_phrase,
'publications': results_page.object_list,
'pages': paginator.num_pages,
'page_range': paginator.page_range,
'page': results_page.number,
'has_next': results_page.has_next(),
'has_previous': results_page.has_previous(),
'next': next,
'previous': previous,
'uri': full_uri,
'result_count': paginator.count,
'is_internal': is_internal(request),
}
return render_to_response('synapse/results.html', context)
else:
if just_author:
msg = u'Your search for <em>%s</em> returned no results. If this is an MSK author, please contact <a href="/comments/" alt="Synapse Comments" title="Synapse Comments">the Synapse Administrators</a>.' % search_phrase
else:
msg = u'Your search for <em>%s</em> returned no results. Please broaden your search and try again.' % search_phrase
form = AdvancedSearchForm()
return render_to_response(
'synapse/search.html', {
'form': form,
'show_dmt': False,
'is_internal': is_internal(request),
'msg': msg
})
else:
msg = u'Please enter at least one search term.'
form = AdvancedSearchForm()
return render_to_response(
'synapse/search.html', {
'form': form,
'show_dmt': False,
'is_internal': is_internal(request),
'msg': msg
})
