def page(request,querySet,**kwargs):
after_range_num = kwargs.get('after_range_num', AFTER_RANGE_NUM)
bevor_range_num = kwargs.get('bevor_range_num', BEVOR_RANGE_NUM)
per_page_num = kwargs.get('page_num', PAGE_NUM)
page=kwargs.get('page',None)
try:
if page==None:
page=int(request.REQUEST.get('page', '1'))
if page<1:
page=1
except:
page=1
paginator =Paginator(querySet,per_page_num)
try:
if type(querySet)==RawQuerySet:
paginator._count = len(list(querySet))
pages = paginator.page(page)
else:
pages = paginator.page(page)
except:
if type(querySet)==RawQuerySet:
paginator._count = len(list(querySet))
pages = paginator.page(1)
else:
pages = paginator.page(1)
if page >= after_range_num:
page_range = paginator.page_range[page-after_range_num:page+bevor_range_num]
else:
page_range = paginator.page_range[0:int(page)+bevor_range_num]
return {'pages': pages, 'page_range': page_range}
#原始sql查询分页
# Attributes:
# querySet 分页数据集
# page_num 每页显示的数目, 默认是10
# after_range_num: int类型, 默认是4
# bevor_range_num: int类型, 默认是4
# current_page: int 当前页数,must
# def raw_sql_page(request,sql,**kwargs):
# after_range_num = kwargs.get('after_range_num', AFTER_RANGE_NUM)
# bevor_range_num = kwargs.get('bevor_range_num', BEVOR_RANGE_NUM)
# per_page_num = kwargs.get('page_num', PAGE_NUM)
#
# try:
# page=int(request.GET.get('page', '1'))
# if page<1:
# page=1
# except:
# print "数据转换出错！"
# pass
# sql+=" limit "+per_page_num*(page-1)+","+per_page_num*page
#
#
def show_films_for_tag(request, tag=None, page_id = "1"):
"""
Shows a sortable and pageable list of films for a tag
"""
if tag == None:
raise Http404
recom_helper = RecomHelper()
films_list = recom_helper.get_films_for_tag(tag = tag)
logger.debug(films_list)
paginate_by = 75
paginator = Paginator(films_list, paginate_by)
paginator._count = len(films_list)
try:
films = paginator.page(page_id)
except (EmptyPage, InvalidPage):
films = paginator.page(paginator.num_pages)
context = {
'tag': tag,
'films': films,
}
return render_to_response(templates['FILMS_FOR_TAG'],
context,
context_instance=RequestContext(request))
def paginate(l, args):
l = l or []
page, delim, sorting = args.partition(DELIM)
if sorting:
if isinstance(l, QuerySet):
l = l.order_by(sorting)
elif isinstance(l, list):
default = ''
if sorting.endswith('_date'):
default = datetime.datetime.utcfromtimestamp(0)
l.sort(key=lambda i: getattr(i, sorting)
if getattr(i, sorting) else default)
paginator = Paginator(l, settings.PAGINATE_BY)
try:
paginator.len
except AttributeError:
paginator._count = len(list(l))
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
page_number = 1
try:
page = paginator.page(page_number)
except EmptyPage:
page = paginator.page(1)
return page
def paginate_datalist(dataList, recordNum, request, rtnPara,pageNum=12):
"""
:rtype : object
:param dataList: 要分页的数据集合
:param recordNum: 数据集长度
:param request: HttpRequest
:param rtnPara: 返回的Map Dict
:param pageNum: 默认12条记录
"""
paginator = Paginator(dataList, pageNum) # 每页15行
paginator._count = recordNum
page = request.GET.get('page')
try:
recList = paginator.page(page)
except PageNotAnInteger:
recList = paginator.page(1)
except EmptyPage:
recList = paginator.page(paginator.num_pages)
rtnPara['list_paginator'] = paginator
rtnPara['record_num'] = recordNum
rtnPara['recList'] = recList
querySTRING=request.META['QUERY_STRING'].encode('utf8')
idxPage = querySTRING.find('page')
if idxPage == -1:
rtnPara['prefix'] = '?%s' % querySTRING
else:
rtnPara['prefix'] = '?%s' % querySTRING[:idxPage - 1]
def get_paginator(self, queryset, limit):
paginator = Paginator(queryset, per_page=limit)
paginator.has_limit = bool(limit)
# Cache count for paginator to prevent redundant calls between requests
if settings.DATA_CACHE_ENABLED:
key = cache_key('paginator', kwargs={
'queryset': queryset
})
count = cache.get(key)
if count is None:
count = _count(queryset)
cache.set(key, count)
else:
count = _count(queryset)
paginator._count = count
if not limit:
# Prevent division by zero error in case count is zero
paginator.per_page = max(count, 1)
return paginator
def show_films_for_tag(request, tag=None, page_id="1"):
"""
Shows a sortable and pageable list of films for a tag
"""
if tag == None:
raise Http404
recom_helper = RecomHelper()
films_list = recom_helper.get_films_for_tag(tag=tag)
logger.debug(films_list)
paginate_by = 75
paginator = Paginator(films_list, paginate_by)
paginator._count = len(films_list)
try:
films = paginator.page(page_id)
except (EmptyPage, InvalidPage):
films = paginator.page(paginator.num_pages)
context = {
'tag': tag,
'films': films,
}
return render_to_response(templates['FILMS_FOR_TAG'],
context,
context_instance=RequestContext(request))
def question(request, question_id):
"""Displays a Question."""
if not request.user.is_authenticated():
question = get_object_or_404(Question, id=question_id)
favourite = False
else:
question = get_object_or_404(Question.objects.extra(
select={
'user_favourite_id':
('SELECT id FROM soclone_favouritequestion '
'WHERE question_id = soclone_question.id '
'AND user_id = %s'),
},
select_params=[request.user.id]),
id=question_id)
favourite = (question.user_favourite_id is not None)
if 'showcomments' in request.GET:
return question_comments(request, question)
answer_sort_type = request.GET.get('sort', DEFAULT_ANSWER_SORT)
if answer_sort_type not in ANSWER_SORT:
answer_sort_type = DEFAULT_ANSWER_SORT
order_by = ANSWER_SORT[answer_sort_type]
paginator = Paginator(
Answer.objects.for_question(question,
request.user).order_by(*order_by),
AUTO_WIKI_ANSWER_COUNT)
# Save ourselves a COUNT() query by using the denormalised count
paginator._count = question.answer_count
page = get_page(request, paginator)
answers = page.object_list
populate_foreign_key_caches(User,
(((question, ),
('author', 'last_edited_by', 'closed_by')),
(answers, ('author', 'last_edited_by'))),
fields=('username', 'gravatar', 'reputation',
'gold', 'silver', 'bronze'))
# Look up vote status for the current user
question_vote, answer_votes = Vote.objects.get_for_question_and_answers(
request.user, question, page.object_list)
title = question.title
if question.closed:
title = '%s [closed]' % title
return render_to_response('question.html', {
'title': title,
'question': question,
'question_vote': question_vote,
'favourite': favourite,
'answers': page.object_list,
'answer_votes': answer_votes,
'page': page,
'answer_sort': answer_sort_type,
'answer_form': AddAnswerForm(),
'tags': question.tags.all(),
},
context_instance=RequestContext(request))
def paginate(objlist, numitems, pagenum, count=None):
paginator = Paginator(objlist, numitems)
if count is not None:
''' raw querylerde count'u disardan sagliyoruz. aksi halde len falan ile almak gerek ki
bu da bellek dertleri yaratabilir.
'''
paginator._count = count
return paginator.page(pagenum)
def question(request, question_id):
"""Displays a Question."""
if not request.user.is_authenticated():
question = get_object_or_404(Question, id=question_id)
favourite = False
else:
question = get_object_or_404(Question.objects.extra(
select={
'user_favourite_id': (
'SELECT id FROM soclone_favouritequestion '
'WHERE question_id = soclone_question.id '
'AND user_id = %s'),
},
select_params=[request.user.id]
), id=question_id)
favourite = (question.user_favourite_id is not None)
if 'showcomments' in request.GET:
return question_comments(request, question)
answer_sort_type = request.GET.get('sort', DEFAULT_ANSWER_SORT)
if answer_sort_type not in ANSWER_SORT:
answer_sort_type = DEFAULT_ANSWER_SORT
order_by = ANSWER_SORT[answer_sort_type]
paginator = Paginator(Answer.objects.for_question(
question, request.user).order_by(*order_by),
AUTO_WIKI_ANSWER_COUNT)
# Save ourselves a COUNT() query by using the denormalised count
paginator._count = question.answer_count
page = get_page(request, paginator)
answers = page.object_list
populate_foreign_key_caches(User, (
((question,), ('author', 'last_edited_by', 'closed_by')),
(answers, ('author', 'last_edited_by'))
),
fields=('username', 'gravatar', 'reputation', 'gold', 'silver',
'bronze'))
# Look up vote status for the current user
question_vote, answer_votes = Vote.objects.get_for_question_and_answers(
request.user, question, page.object_list)
title = question.title
if question.closed:
title = '%s [closed]' % title
return render_to_response('question.html', {
'title': title,
'question': question,
'question_vote': question_vote,
'favourite': favourite,
'answers': page.object_list,
'answer_votes': answer_votes,
'page': page,
'answer_sort': answer_sort_type,
'answer_form': AddAnswerForm(),
'tags': question.tags.all(),
}, context_instance=RequestContext(request))
def paginate(objects, page, n, count=None):
from django.core.paginator import Paginator
paginator = Paginator(objects, n)
if count is not None:
paginator._count = count
current_page = paginator.page(page)
page_range = range(max(1, page-3), min(paginator.num_pages, page+3)+1)
objects = current_page.object_list
return objects, paginator, current_page, page_range
def paginate(objlist, numitems, pagenum, count=None):
paginator = Paginator(objlist, numitems)
if count is not None:
''' raw querylerde count'u disardan sagliyoruz. aksi halde len falan ile almak gerek ki
bu da bellek dertleri yaratabilir.
'''
paginator._count = count
# eğer olmayan bir sayfa istenmişse, mevcut son sayfayı dön
return paginator.page(pagenum) if pagenum <= paginator.num_pages else paginator.page(paginator.num_pages)
def get_paginator(self, queryset, limit):
paginator = Paginator(queryset, per_page=limit)
paginator.has_limit = bool(limit)
# Perform count an update paginator to prevent redundant call
if not limit:
count = len(queryset)
paginator.per_page = count
paginator._count = count
return paginator
def get_paginator(self, queryset, limit):
paginator = Paginator(queryset, per_page=limit)
paginator.has_limit = bool(limit)
# Perform count an update paginator to prevent redundant call
if not limit:
count = len(queryset)
# Prevent division by zero error in case count is zero
paginator.per_page = max(count, 1)
paginator._count = count
return paginator
def paginate(objlist, numitems, pagenum, count=None):
paginator = Paginator(objlist, numitems)
if count is not None:
''' raw querylerde count'u disardan sagliyoruz. aksi halde len falan ile almak gerek ki
bu da bellek dertleri yaratabilir.
'''
paginator._count = count
# eğer olmayan bir sayfa istenmişse, mevcut son sayfayı dön
return paginator.page(
pagenum) if pagenum <= paginator.num_pages else paginator.page(
paginator.num_pages)
def get_most_voted_question(count):
sql = '''
SELECT q.*
FROM qna_question q
JOIN qna_answer a
ON a.question_id = q.id
GROUP BY q.id
ORDER BY SUM(a.votes) DESC
'''
questions = Question.objects.raw(sql)
paginator = Paginator(questions, count)
paginator._count = len(list(questions))
return paginator
def get_popular_questions(count):
sql = '''
SELECT q.*
FROM qna_question q
JOIN qna_answer a
ON a.question_id = q.id
GROUP BY q.id
ORDER BY count(1) DESC
'''
questions = Question.objects.raw(sql)
paginator = Paginator(questions, count)
paginator._count = len(list(questions))
return paginator
def execute(self,view_context):
"""
这个函数主要功能将queryset进行分页，默认每页10条记录，客户端代码不可以更改
更改没有必要
返回一个和分页相关的结果
"""
paginator = Paginator(view_context.queryset,self.item_per_page)#设置每页10
#paginator._count = maxcount() # 最多返回500个结果
paginator._count = view_context.kargs.get("resultcount",maxcount())
request_page_num = self.request_page
total_item = paginator.count
total_page = paginator.num_pages
try:
one_page_content = paginator.page(request_page_num)
current_page = request_page_num
except PageNotAnInteger:
one_page_content = paginator.page(1)
current_page = 1
except EmptyPage:
one_page_content = paginator.page(paginator.num_pages)
current_page = paginator.num_pages
next_page = one_page_content.next_page_number() if one_page_content.has_next() else total_page
prev_page = one_page_content.previous_page_number() if one_page_content.has_previous() else 1
page_bars = 2#2*page_bars + 设置每页多少10
start_index = current_page-page_bars if current_page>page_bars else 1
end_index = start_index +2*page_bars if start_index +2*page_bars < total_page else total_page
page_context = {'page_info':{
'current_page':current_page,
'next_page':next_page,
'prev_page':prev_page,
'total_item':total_item,
'total_page':total_page,
'ceiling_item_count':maxcount(),
'pages_indexs':range(start_index,end_index+1)
},}
url_parameter_dict = {'page':1}
current_view_context = ViewContext(one_page_content,page_context,url_parameter_dict)
return current_view_context.merge(view_context)
def null_orders(request, page=1):
null_orders = ItemType.objects.extra(
select={
'buy_count': 'SELECT COUNT(*) FROM t1 WHERE t1.item_type_id = t2.id and t1.type = %s' % Order.TYPE_BUY,
'sell_count': 'SELECT COUNT(*) FROM t1 WHERE t1.item_type_id = t2.id and t1.type = %s' % Order.TYPE_SELL,
},
tables=[
'"%s" AS "t1"' % Order._meta.db_table,
'"%s" AS "t2"' % ItemType._meta.db_table,
],
where=['buy_count = 0 or sell_count = 0'],
)
p = Paginator(null_orders, 20)
p._count = null_orders.aggregate(Count('id'))
return render(request, 'eve/null_orders.html', {
'page': p.page(page),
})
def question(request, question_id):
if not request.user.is_authenticated():
question = get_object_or_404(Question, id=question_id)
favourite = False
else:
question = get_object_or_404(Question.objects.extra(
select={
'user_favourite_id': (
'SELECT id FROM questionapp_favouritequestion '
'WHERE question_id = questionapp_question.id '
'AND user_id = %s'),
},
select_params=[request.user.id]
), id=question_id)
favourite = (question.user_favourite_id is not None)
Question.objects.update_view_count(question)
if 'showcomments' in request.GET:
return question_comments(request, question)
paginator = Paginator(Answer.objects.for_question(
question, request.user).order_by('score'),20)
paginator._count = question.answer_count
page = get_page(request, paginator)
answers = page.object_list
question_vote, answer_votes = Vote.objects.get_for_question_and_answers(
request.user, question, page.object_list)
title = question.title
if question.closed:
title = '%s [closed]' % title
related_questions = list(set(Question.objects.filter(tags__in=question.tags.all()).exclude(id = question.id)))
if len(related_questions) > 10:
related_questions = related_questions[:10]
return render_to_response('question.html', {
'title': title,
'question': question,
'question_vote': question_vote,
'favourite': favourite,
'answers': page.object_list,
'answer_votes': answer_votes,
'page': page,
'answer_sort': 'votes',
'answer_form': AddAnswerForm(),
'related_questions':related_questions,
'tags': question.tags.all(),
}, context_instance=RequestContext(request))
def paginate(queryset, number, size=pagination_size_default):
try:
number = int(number)
except (ValueError, TypeError):
number = 1
pages = Paginator(queryset, size)
if isinstance(queryset, RawQuerySet):
pages._count = len(list(queryset))
result = { "pages": pages, "count": pages.count, "jump": jump(pages, number) }
if pages.num_pages > 1:
result["paginated"] = True
else:
result["paginated"] = False
try:
result["page"] = pages.page(number)
except InvalidPage:
# no page, go to 1
result["page"] = pages.page(1)
return result
def get_current_page(request, objects, **kwargs):
"""Template for paging
`objects` is the universe of the set.
Returns a subset of `objects` according to the given page.
"""
# Show 25 items per page by default
paginator = Paginator(objects, kwargs.get('slice', 25))
page = request.GET.get('page')
paginator._count = kwargs.get('count')
try:
objects = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
objects = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
objects = paginator.page(paginator.num_pages)
return objects
def get_context_data(self, **kwargs):
search = self.request.GET['s'] if 's' in self.request.GET else ''
category = self.request.GET['category'] if 'category' in self.request.GET else ''
if search:
from geopy import geocoders
try:
geocoder = geocoders.GoogleV3()
place, (latitude, longitude) = geocoder.geocode(search, exactly_one=False)[0]
except ValueError as e:
context = super(SearchView, self).get_context_data(**kwargs)
context['geocoder_error'] = "There was an error geocoding the location provided for the search. Please try again later or try a different search."
return context
businesses = Business.search(latitude=latitude, longitude=longitude, radius=25, category=category)
businesses_paginated = Paginator(businesses, 24)
businesses_paginated._count = len(list(businesses))
page = self.request.GET.get('page')
try:
businesses_page = businesses_paginated.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
businesses_page = businesses_paginated.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
businesses_page = businesses_paginated.page(businesses_paginated.num_pages)
context = super(SearchView, self).get_context_data(**kwargs)
context['businesses_page'] = businesses_page
context['business_objects'] = businesses_page.object_list
context['categories'] = Category.objects.all()
context['selected_category'] = category
context['search_value'] = search
return context
def view_enquiries(request):
#query = 'Select * from sway_lead where status not in (1,2) order by nextfollowupdate desc NULLS LAST, status desc' %request.user.studiouser.studio_id
#leads = Lead.objects.raw(query)
leads = Lead.objects.filter(Q(studio = request.user.studiouser.studio_id)).exclude(status__in=[1,2])
q = leads.extra(select={'date_due_null': 'CASE WHEN nextfollowupdate is null THEN 0 ELSE 1 END'})
q = q.extra(order_by=['-date_due_null','-nextfollowupdate','-status'])
print q.query
leads = q
##leads = leads.reverse()
paginator = Paginator(leads, 10,0,True) # Show 10 leads per page
paginator._count = len(list(leads))
page = request.GET.get('page')
try:
leads = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
leads = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
leads = paginator.page(paginator.num_pages)
print leads
return render_to_response('sway/view_enquiries.html', {"enquiryList": leads}, context_instance=RequestContext(request))
def userhome(request):
if not request.session.get('logged_in'):
return HttpResponseRedirect('/')
link = request.build_absolute_uri('/')
instance = request.user
userid = instance.id
queryset = Vehicles.objects.raw('''SELECT * from myapp_vehicles LEFT JOIN myapp_userlikes on myapp_vehicles.id = myapp_userlikes.vehicle_id and myapp_userlikes.liker_id = %s ''', [userid])
paginator = Paginator(queryset,5)
paginator._count = len(list(queryset))
page = request.GET.get('page')
try:
# create Page object for the given page
queryset = paginator.page(page)
except PageNotAnInteger:
# if page parameter in the query string is not available, return the first page
queryset = paginator.page(1)
except EmptyPage:
# if the value of the page parameter exceeds num_pages then return the last page
queryset = paginator.page(paginator.num_pages)
return render(request,"Automobile_sales/userhome.html",{'queryset': queryset,'userhomepage': True,'userid':userid,'link':link})
def get_paginator(self, queryset, limit):
paginator = Paginator(queryset, per_page=limit)
paginator.has_limit = bool(limit)
# Cache count for paginator to prevent redundant calls between requests
if settings.DATA_CACHE_ENABLED:
key = cache_key('paginator', kwargs={'queryset': queryset})
count = cache.get(key)
if count is None:
count = _count(queryset)
cache.set(key, count)
else:
count = _count(queryset)
paginator._count = count
if not limit:
# Prevent division by zero error in case count is zero
paginator.per_page = max(count, 1)
return paginator
def posts_list(request, topic_pk):
topic = get_object_or_404(Topic, pk=topic_pk)
if topic.is_deleted:
return HttpResponseGone()
posts = Post.objects.filter(topic=topic, is_deleted=False)\
.select_related('author').order_by('created')
paginator = Paginator(posts, settings.FORUM_POSTS_PER_PAGE)
paginator._count = topic.posts_count()
try:
page = paginator.page(request.GET.get('page', 1))
except PageNotAnInteger:
page = paginator.page(1)
except EmptyPage:
page = paginator.page(paginator.num_pages)
topic.view_count += 1
topic.save(update_fields=['view_count'])
ctx = {
'topic': topic,
'posts': page,
}
return render(request, 'forum/posts_list.html', ctx)
def person_gallery_data(request, person_id, person = None, page = 1):
'''
Gets image data for a particular person
'''
image_list = Image.objects.raw(""" SELECT i.*
FROM gallery_image i
INNER JOIN gallery_tag t
ON i.id = t.image_id
AND t.person_id = {0}
ORDER BY i.creation_date DESC
""".format(person.id))
paginator = Paginator(image_list, 12) #show 12 per request, divisable by lots of numbers
#Get count to paginate raw query
cursor = connection.cursor()
cursor.execute(""" SELECT COUNT(*)
FROM gallery_image i
INNER JOIN gallery_tag t
ON i.id = t.image_id
AND t.person_id = {0}
""".format(person.id))
paginator._count = cursor.fetchone()[0]
try:
images = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
images = paginator.page(1)
except EmptyPage:
# If page is out of range return blank
return HttpResponse('[]', content_type="application/json")
data = serializers.serialize(
'json', images, fields=('id','title', 'thumbnail', 'large_thumbnail', 'original_image', 'latitude', 'thumbnail_width', 'thumbnail_height', 'large_thumbnail_width', 'large_thumbnail_height')) #Added latitude to unhide map button
return HttpResponse(data, content_type="application/json")
def page(self, number, per_page):
if not number:
if not self._request:
raise Exception('Requires with_request')
number = self.get_page_from_request(self._request)
if self._group_by and not self._count:
qset = deepcopy(self.queryset).values(*self._group_by)
if self._distinct:
qset = qset.distinct()
self._count = qset.count()
per_page = per_page or self.PER_PAGE
paginator = Paginator(self.instance.rows, per_page)
if self._count:
hits = max(1, self._count - paginator.orphans)
paginator._num_pages = int(ceil(hits / float(per_page)))
# The following line also avoids an extra (and wrong) COUNT(*) query.
paginator._count = self._count
try:
current_page = paginator.page(number)
except (EmptyPage, InvalidPage):
page_number = 1
current_page = paginator.page(page_number)
paginator.limited_page_range = CustomPaginator.get_page_range(paginator.num_pages, number)
return current_page
def thread_post(request, post_form_id=None, post=None,
depth="v", subtopic=True):
""" Renders (part of) the thread starting from the specified post.
Passes the `subtopic` parameter to the template, which annotates it with
"Showing a part of the thread" message.
Is also used for rendering whole threads. """
if post is not None: # probably unused ATM.
top_post = post
elif post_form_id is not None:
top_post = _get_that_post(request, post_form_id)
else: # should not ever happen.
_log.error("Invalid invocation of the thread_post.")
import traceback
_log.debug("".join(traceback.print_stack()))
return HttpResponseServerError()
## Determine sutopic by depth:
subtopic = (top_post.depth != 1)
thr = top_post.thread
if not thr.category.can_read(request.user):
raise PermissionError("You are not allowed to read this thread")
render_dict = {}
## Helper for retreiving int values from request.GET
def l_getintparam(param, default=''):
prm = request.GET.get(param, '')
## callable is allowed for slight optimization.
return int(prm) if prm.isdigit() \
else (default() if callable(default) else default)
l_str2int = lambda x: Post._str2int(x)
l_int2str = lambda v: Post._int2str(v).rjust(Post.steplen, '0')
# starts from '1', apparently:
l_getinterval = lambda parent, left, right: (parent + l_int2str(left + 1),
parent + l_int2str(right + 1))
### Pagination (mildly obsolete):
## overridable ppp.
ppp = l_getintparam('ppp', lambda: request.user.get_user_settings().ppp)
from django.core.paginator import Paginator, InvalidPage
paginator = Paginator(SliceHack(), ppp)
# This might be problematic if some posts got deleted/moved.
# Bit more safe way (but not completely good either) would be something
# like
# paginator._count = \
# l_str2int(top_post.get_children().reverse()[:1].path[-Post.steplen]
# (with consideration for empty children QS).
paginator._count = top_post.get_children_count()
page_obj = paginator.page(request.GET.get("page", 1))
slice = page_obj.object_list.slice
# first and last post; second element is the first post to *not* include:
pinterval = l_getinterval(top_post.path, slice.start, slice.stop)
maxdepthd = l_getintparam('md', 28)
nfsib = l_getintparam('nfsib', None) # full next siblings
# TODO: can find it dynamically (and then cache)!
maxdepth = top_post.depth + maxdepthd
#qs = Post.objects.filter(
fsibpath = None
if nfsib: # 1. show fully target post and few next siblings.
parentpath = top_post.path[:-Post.steplen]
tpnum = l_str2int(top_post.path[-Post.steplen:])
fsibpath = parentpath + l_int2str(tpnum + nfsib) # some further sibling.
qs = Post.objects.filter(
path__range=(
top_post.path,
fsibpath
)
)
else:
qs = top_post.get_descendants()
qs = qs.filter(
thread=thr,
#depth__gte=top_post.depth,
depth__lte=maxdepth,
)
qs = qs.annotate(
abuse=Count('sb_abusereport_set')
).extra(
select={
"numanswers": """CASE WHEN snapboard_post.depth = %d THEN
(SELECT COUNT(*) FROM snapboard_post AS child WHERE (
child.path LIKE (snapboard_post.path || '%%%%') AND
child.depth > snapboard_post.depth
))
ELSE 0 END
""" % maxdepth,
# "abuse": 0,
}
).select_related(depth=1
## A problem: .only() or .defer() together with .select_related()
## significantly increase query's execution time.
#).only(
# 'depth', 'texth', 'date', 'censor', 'freespeech', 'previous',
# 'tlid', 'user__username', 'user__is_staff'
#.defer(
# 'text', 'path', 'thread', 'ip',
#).select_related(depth=1)
)
# ! XXX: temporary hack?
top_post.abuse = top_post.sb_abusereport_set.count()
sibqs = fsibqs = None
nsib = l_getintparam('nsib', None) # next siblings, short.
## full query on nfsib; push away nsib's paths.
if nsib:
sibqs = top_post.get_siblings(
).filter(
thread=thr,
path__gt=(fsibpath if fsibpath else top_post.path)
).annotate(
abuse=Count('sb_abusereport_set')
).extra(
select={
"numanswers": """
SELECT COUNT(*) FROM snapboard_post AS child WHERE (
child.path LIKE (snapboard_post.path || '%%%%') AND
child.depth > snapboard_post.depth
)""",
"nsib": "1",
}
).select_related(depth=1
)
sibqs = sibqs[:nsib]
## Only enable pagination filtering if a page is specified.
## (Can grab a specific page if willing.)
if request.GET.get('page', ''):
#qs = qs.filter(path__range=pinterval,)
## Do not include the end of range:
qs = qs.filter(path__gte=pinterval[0], path__lt=pinterval[1])
# finally, retreive and annotate the result.
if subtopic or True: ## XXX.
listdepth = top_post.depth
qsl = list(qs) # grab the data.
res = [top_post] + qsl # resulting page tree.
if request.GET.get('nav', None) == '1' or True: ## XXX.
top_post.nav = True
top_post.n_down = top_post.get_next_sibling()
top_post.n_up = top_post.get_prev_sibling()
ancestors = top_post.get_ancestors(
#).filter(depth__gte=2 # avoid the main post in there - or not
).annotate(abuse=Count('sb_abusereport_set')
).reverse()
top_post.n_left = ancestors[0] if ancestors.exists() else None
# if len(ancestors) == 1:
# / if depth = 2:
# top_post.n_left = "thr".
top_post.n_right = qsl[0] if qsl else None
ma = request.GET.get('ma', '1') # max. ancestors.
if ma is not None and ma.isdigit():
ma = int(ma)
res = list(ancestors[:ma])[::-1] + res
else:
res = list(ancestors)[::-1] + res
if nsib:
res = res + list(sibqs)
post_list = get_flathelper_list(qs=res)
top_post.is_flat = False # fixit.
#top_post = None # there ain't no top_post in here!.. But not a problem, okay.
# (and actually can show it; but probably don't need)
else:
## sorting by last answer.
## ! Might not make any sense right now.
if request.GET.get('sl', None) == '1':
### v1: unoptimal:
#for post in post_list:
# post.last_answer_date = \
# Post.get_tree(post).order_by("-date")[0].date
#post_list = sorted(post_list, key=lambda p: p.last_answer_date,
# reverse=True)
### v2: SQLed.
## Not sure what 'ESCAPE' is meant to do here. Grabbed from
## treebeard queries:
## cls.objects.filter(path__startswith=parent.path,
## depth__gte=parent.depth)
## !! XXX: somewhat SQLite-specific (concat is '||')
## XXX: Move into the model manager?
post_list = post_list.extra(select={
"lastanswer": """SELECT date FROM snapboard_post AS child
WHERE (child.path LIKE (snapboard_post.path || '%%') AND
child.depth >= snapboard_post.depth)
ORDER BY date DESC LIMIT 1 """
}).order_by("-lastanswer")
post_list = get_flathelper_list(qs=qs)
#qs = qs[1:] # was necessary for skipping top_post in its get_tree.
# Get list of all replies.
#post_list = Post.get_children(top_post) # Paginated by this list.
listdepth = 2
# Additional note: annotating watched posts in the tree can be done, for
# example, by using
# WatchList.objects.filter(post__in=pl, user=request.user),
# and, in the template, "{% post.id in watched_list %}".
# (select related, '[wi.post.id for wi in ...]' and etc. might also be
# needed).
# This, of course, requires that post lists are retreived here in view,
# rather than in the template.
render_dict.update({
'top_post': top_post,
'post_list': post_list,
'thr': thr,
'paginator': paginator,
'page_obj': page_obj,
'subtopic': subtopic,
'listdepth': listdepth, # at which depth the post_list is.
'maxdepth': maxdepth,
})
return render_to_response('snapboard/thread',
render_dict,
context_instance=RequestContext(request, processors=extra_processors))
def get_ajax_response(self, request):
# Item count
queryset = self.get_queryset()
if self.fake_count:
total_count = 10000
else:
total_count = queryset.count()
json_data = {
'aaData': [],
'iTotalRecords': total_count,
'iTotalDisplayRecords': total_count
}
search_terms = request.GET.get('sSearch', '').lower().strip().split()
filtered_queryset = queryset
# Figure out the queryable columns for sorting and searching.
def check_for_field(model, field_name):
try:
return model._meta.get_field(field_name)
except FieldDoesNotExist:
return False
queryable_columns = []
do_distinct = False
for column_index, column in enumerate(self.get_columns()):
if (not isinstance(column, AttributeTableColumn)
or not column.searchable):
continue
failed = False
column_name = column.get_column_name()
u_split = column_name.split('.')
model = queryset.model
for index, attr in enumerate(u_split):
"""The logic is a little complex here. What we're trying to do
is iterate through the "dot" attributes until we verify that
the final attribute in the chain is NOT another related field,
which would mean we could not query it with our search. In
other words, we are compiling all of the attributes in the
table which are queryable.
The logic is:
1) Check if the attribute even exists on the model as a field;
if not, abort.
2) If it exists and it is a related field (e.g. foreignkey),
then ignore it if it's the last element to be searched.
If it is not the last element in the dot chain, then go
back through the loop using the model associated with the
related field until we do get to the end."""
f_ = check_for_field(model, attr)
if not f_:
failed = True
break
if isinstance(f_, ForeignObjectRel):
if isinstance(f_, ManyToOneRel):
do_distinct = True
new_model = f_.model
if new_model == model:
new_model = getattr(f_, 'related_model', new_model)
elif (getattr(f_, 'remote_field', None)
and f_.remote_field.model):
new_model = f_.remote_field.model
else:
new_model = None
if new_model:
if index == len(u_split) - 1:
failed = True
break
model = new_model
elif index != len(u_split) - 1:
failed = True
break
# It met all the conditions, so add to the query.
if not failed:
queryable_columns.append(
[column_name.replace('.', '__'), column, column_index])
for extra_field in self.extra_search_fields:
queryable_columns.append([extra_field, None, None])
# Handle searching.
if len(search_terms) > 0:
queries = []
for term in search_terms:
query = None
for column_name, column, column_index in queryable_columns:
search_key = "{}__icontains".format(column_name)
new_q = Q(**{search_key: term})
if query is None:
query = new_q
else:
query |= new_q
if query is not None:
queries.append(query)
if len(queries) > 0:
filtered_queryset = filtered_queryset.filter(
*queries).distinct()
if not self.fake_count:
json_data['iTotalDisplayRecords'] = filtered_queryset.count()
# Handle sorting.
# First figure out which columns we are sorting.
sort_indices = []
for i in range(len(self.get_columns())):
sort_index = request.GET.get('iSortCol_{}'.format(i))
if sort_index is not None:
sort_indices.append([
int(sort_index),
request.GET.get('sSortDir_{}'.format(i))
])
sort_terms = []
for column_name, column, column_index in queryable_columns:
if column_index is None:
continue
# See if this column is being sorted.
if self.is_batch():
cidx = column_index + 1
else:
cidx = column_index
if column.sortable:
for sort_index, sort_direction in sort_indices:
if sort_index == cidx:
sort_term = column_name
if sort_direction == 'desc':
sort_term = "-{}".format(column_name)
else:
sort_term = column_name
sort_terms.append(sort_term)
sort_terms.append('id')
ajax_limit = self.get_ajax_limit()
if len(sort_terms) > 0 and not self.skip_ajax_sort:
filtered_queryset = filtered_queryset.order_by(*sort_terms)
if do_distinct:
filtered_queryset = filtered_queryset.distinct()
if ajax_limit:
filtered_queryset = filtered_queryset[:ajax_limit]
# Pagination
page_limit = int(request.GET.get('iDisplayLength', 10))
page = (int(request.GET.get('iDisplayStart', 0)) / page_limit) + 1
prefetch_fields = self.get_prefetch_fields()
paginator = Paginator(
filtered_queryset.prefetch_related(*prefetch_fields), page_limit)
# HACK: Makes paginator not check length of QS which is useful for
# large queries.
if self.fake_count:
paginator._count = ajax_limit
try:
items = paginator.page(page)
except PageNotAnInteger:
items = paginator.page(1)
except EmptyPage:
raise Http404
# Render cell content
qs = items.object_list
rows = self.generate_rows(qs)
for row in rows:
row_data = []
for cell in row:
data = cell.content
if isinstance(data, datetime):
data = convert_render_datetime(data)
row_data.append(str(data))
json_data['aaData'].append(row_data)
return HttpResponse(json.dumps(json_data),
content_type="application/json")
def get_paginator(self, queryset, per_page, orphans=0, allow_empty_first_page=True):
paginator = Paginator(queryset, per_page, orphans=0, allow_empty_first_page=True)
paginator._count = len(list(queryset))
return paginator
def get_numberbysource_view(self, context):
release_content_type = ContentType.objects.get_for_model(Release)
# numberbysource view - number of declarations by source per category
context['layout'] = 'numberbysource'
if context['category'] == 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entrylineitem"."key" = 'Source')
GROUP BY value, release_id, category_id ORDER BY c DESC''', [])
elif context['category'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entrylineitem"."key" = 'Source'
AND "interests_register_entry"."release_id" = %s)
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['release_id']])
elif context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entry"."category_id" = %s
AND "interests_register_entrylineitem"."key" = 'Source')
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['category_id']])
else:
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entry"."category_id" = %s
AND "interests_register_entrylineitem"."key" = 'Source'
AND "interests_register_entry"."release_id" = %s)
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['category_id'], context['release_id']])
paginator = Paginator(data, 20)
paginator._count = len(list(data))
page = self.request.GET.get('page')
try:
data_paginated = paginator.page(page)
except PageNotAnInteger:
data_paginated = paginator.page(1)
except EmptyPage:
data_paginated = paginator.page(paginator.num_pages)
for row in data_paginated:
sources = models.InformationSource.objects.filter(
content_type=release_content_type, object_id=row.release.id)
if sources:
source_url = sources[0].source
else:
source_url = ''
row.release.source_url = source_url
context['data'] = data_paginated
return context
def get_number_by_representative_view(self, context):
release_content_type = ContentType.objects.get_for_model(Release)
# numberbyrepresentative view - number of declarations per person per category
context['layout'] = 'numberbyrepresentative'
# Custom sql used as:
# Entry.objects.values('category', 'release', 'person').annotate(c=Count('id')).order_by('-c')
# ... returns a ValueQuerySet with foreign keys, not model instances
if context['category'] == 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[])
elif context['category'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."release_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['release_id']])
elif context['category'] != 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."category_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['category_id']])
else:
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."category_id" = %s
AND "interests_register_entry"."release_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['category_id'], context['release_id']])
paginator = Paginator(data, 20)
paginator._count = len(list(data))
page = self.request.GET.get('page')
try:
data_paginated = paginator.page(page)
except PageNotAnInteger:
data_paginated = paginator.page(1)
except EmptyPage:
data_paginated = paginator.page(paginator.num_pages)
for row in data_paginated:
sources = models.InformationSource.objects.filter(
content_type=release_content_type, object_id=row.release.id)
if sources:
source_url = sources[0].source
else:
source_url = ''
row.release.source_url = source_url
context['data'] = data_paginated
return context
def get_numberbysource_view(self, context):
release_content_type = ContentType.objects.get_for_model(Release)
# numberbysource view - number of declarations by source per category
context['layout'] = 'numberbysource'
if context['category'] == 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entrylineitem"."key" = 'Source')
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[])
elif context['category'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entrylineitem"."key" = 'Source'
AND "interests_register_entry"."release_id" = %s)
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['release_id']])
elif context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entry"."category_id" = %s
AND "interests_register_entrylineitem"."key" = 'Source')
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['category_id']])
else:
data = Entry.objects.raw(
'''SELECT max("interests_register_entrylineitem"."id") as id,
value, count(*) as c, release_id, category_id
FROM "interests_register_entrylineitem"
INNER JOIN "interests_register_entry"
ON ("interests_register_entrylineitem"."entry_id"
= "interests_register_entry"."id")
WHERE ("interests_register_entry"."category_id" = %s
AND "interests_register_entrylineitem"."key" = 'Source'
AND "interests_register_entry"."release_id" = %s)
GROUP BY value, release_id, category_id ORDER BY c DESC''',
[context['category_id'], context['release_id']])
paginator = Paginator(data, 20)
paginator._count = len(list(data))
page = self.request.GET.get('page')
try:
data_paginated = paginator.page(page)
except PageNotAnInteger:
data_paginated = paginator.page(1)
except EmptyPage:
data_paginated = paginator.page(paginator.num_pages)
for row in data_paginated:
sources = models.InformationSource.objects.filter(
content_type=release_content_type,
object_id=row.release.id
)
if sources:
source_url = sources[0].source
else:
source_url = ''
row.release.source_url = source_url
context['data'] = data_paginated
return context
def get_number_by_representative_view(self, context):
release_content_type = ContentType.objects.get_for_model(Release)
# numberbyrepresentative view - number of declarations per person per category
context['layout'] = 'numberbyrepresentative'
# Custom sql used as:
# Entry.objects.values('category', 'release', 'person').annotate(c=Count('id')).order_by('-c')
# ... returns a ValueQuerySet with foreign keys, not model instances
if context['category'] == 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[])
elif context['category'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."release_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['release_id']])
elif context['category'] != 'all' and context['release'] == 'all':
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."category_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['category_id']])
else:
data = Entry.objects.raw(
'''SELECT max(id) as id, category_id, release_id, person_id,
count(*) as c FROM "interests_register_entry"
WHERE "interests_register_entry"."category_id" = %s
AND "interests_register_entry"."release_id" = %s
GROUP BY category_id, release_id, person_id ORDER BY c DESC''',
[context['category_id'], context['release_id']])
paginator = Paginator(data, 20)
paginator._count = len(list(data))
page = self.request.GET.get('page')
try:
data_paginated = paginator.page(page)
except PageNotAnInteger:
data_paginated = paginator.page(1)
except EmptyPage:
data_paginated = paginator.page(paginator.num_pages)
for row in data_paginated:
sources = models.InformationSource.objects.filter(
content_type=release_content_type,
object_id=row.release.id
)
if sources:
source_url = sources[0].source
else:
source_url = ''
row.release.source_url = source_url
context['data'] = data_paginated
return context
def search_list(request, page = -1, page_size = -1):
search = request.GET.get('search').decode('utf-8')
search = request.GET.get('search')
lokalita = str(request.POST.get('lokalita')).decode('utf-8')
typ = str(request.POST.get('typ')).decode('utf-8')
kategoria = str(request.POST.get('kategoria')).decode('utf-8')
s_fotkou = str(request.POST.get('s_fotkou')).decode('utf-8')
s_form = str(request.GET.get('s')).decode('utf-8')
#test if form was submited
if s_form != "None":
if request.session.get('search', False):
del request.session['search']
if request.session.get('lokalita', False):
del request.session['lokalita']
if request.session.get('typ', False):
del request.session['typ']
typ = u"vsetky"
if request.session.get('kategoria', False):
del request.session['kategoria']
if request.session.get('s_fotkou', False):
del request.session['s_fotkou']
if(page == -1 and page_size == -1):
return HttpResponseRedirect("/vyhladavanie/1/10/?search=" + search)
page_size = int(page_size)
page = int(page)
sql_query = u"SELECT * FROM frontend_ad WHERE active=True"
session_info = request.session.get('search', False)
#depend of the type of request we handle variables and sessions
if request.method == 'POST':
if session_info:
request.session['lokalita'] = lokalita
request.session['typ'] = typ
request.session['kategoria'] = kategoria
request.session['s_fotkou'] = s_fotkou
else:
request.session['search'] = search
request.session['lokalita'] = lokalita
request.session['typ'] = typ
request.session['kategoria'] = kategoria
request.session['s_fotkou'] = s_fotkou
else:
search = request.GET.get('search').decode('utf-8')
#search = request.GET.get('search')
if session_info and str(request.session.get('search', False)).decode('utf-8') != search:
del request.session['search']
del request.session['lokalita']
del request.session['typ']
typ = u"vsetky"
del request.session['kategoria']
del request.session['s_fotkou']
elif session_info or str(request.session.get('search', False)).decode('utf-8') == "":
lokalita = request.session.get('lokalita', "cela-sr")
typ = request.session.get('typ', None)
kategoria = request.session.get('kategoria', "vsetky")
s_fotkou = request.session.get('s_fotkou', None)
#constructing the query depending on the submited info from the search and filter form
if (request.method == 'POST' or
(request.method == 'GET' and session_info and str(request.session.get('search', False)).decode('utf-8') == search) or
(request.method == 'GET' and str(request.session.get('search', False)).decode('utf-8') == "")):
if lokalita != u"cela-sr":
sql_query += u" AND city_id=" + lokalita
if kategoria != u"vsetky":
sql_query += u" AND category_id=" + kategoria
if typ != u"vsetky":
if typ == u"ponuka":
sql_query += u" AND type_of_ad=True"
else:
sql_query += u" AND type_of_ad=False"
if s_fotkou == u"1":
sql_query += u" AND id IN (SELECT ad_id FROM frontend_adimage)"
if search is not None:
sql_query += u" AND (text_of_ad ILIKE '%%" + search + u"%%' OR title ILIKE '%%" + search + u"%%')"
ads_list = Ad.objects.raw(sql_query.encode('utf-8'))
ads_count = sum(1 for result in ads_list)
paginator = Paginator(ads_list, page_size)
paginator._count = len(list(ads_list))
try:
ads = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
ads = paginator.page(1)
except (EmptyPage, InvalidPage):
# If page is out of range (e.g. 9999), deliver last page of results.
ads = paginator.page(paginator.num_pages)
if ads_count > 0:
for ad in ads.object_list:
ad_id = ad.id
try:
ad.image = AdImage.objects.filter(ad=ad_id)
except IndexError:
return HttpResponseRedirect('/')
info_for_template = {}
info_for_template['title'] = u"Výpis výsledkov pre vyhľadávaný reťazec " + search
if(search == ""):
info_for_template['title2'] = u"Výsledky vyhľadávania"
else:
info_for_template['title2'] = u"Výsledky vyhľadávania pre: " + search
if(lokalita != "cela-sr" and lokalita != "None"):
city_name = unicode(City.objects.filter(id=lokalita)[0])
info_for_template['title'] = info_for_template['title'] + u" v meste " + city_name
if(search == ""):
info_for_template['title2'] = u"Výsledky vyhľadávania pre mesto " + city_name
if(kategoria != "vsetky" and kategoria != "None"):
category_name = unicode(Category.objects.filter(id=kategoria)[0])
info_for_template['title'] = info_for_template['title'] + u", v kategórii " + category_name
if(search == ""):
if(lokalita == "cela-sr"):
info_for_template['title2'] = u"Výsledky vyhľadávania pre kategóriu " + category_name
else:
city_name = unicode(City.objects.filter(id=lokalita)[0])
info_for_template['title2'] = u"Výsledky vyhľadávania pre mesto " + city_name + u" a kategóriu " + category_name
info_for_template['crumbs_text'] = u"Vyhľadávanie"
info_for_template['ads_count'] = ads_count
info_for_template.update(makeUrls("vyhladavanie", page, page_size, paginator.num_pages, None, search))
cities = returnCitiesWithAds()
return render_to_response('mesto.html', {'search': search, 'ads': ads, 'page_size': page_size,
'countInfo': countInfo, 'formInfo': formInfo,
'recentNews': recentNews, 'info_for_template': info_for_template,
'lokalita': lokalita, 'typ': typ, 'kategoria': kategoria,
's_fotkou': s_fotkou, 'cities': cities},
context_instance=RequestContext(request))
