def list(request, listing_id):
user = users.GetCurrentUser()
if user is None:
return http.HttpResponseForbidden('You must be signed in to view listing values')
listing_values = None
listing = None
lvs_paginator = None
if request.GET.has_key('page'):
page = int(request.GET['page'])
else:
page = 0
if listing_id:
listing = get_listing(listing_id)
lvs = ListingValue.all().order('-date').filter('listing_key = ', str(listing.key()))
lvs_paginator = ObjectPaginator(lvs, 10)
listing_values = lvs_paginator.get_page(page)
if listing is None or listing_values is None or listing_id is None:
return http.HttpResponseNotFound(
'No values exists for that listing (%r)' %
listing_id)
paginator = {}
paginator['has_previous_page'] = lvs_paginator.has_previous_page(page)
paginator['has_next_page'] = lvs_paginator.has_next_page(page)
paginator['next_page_number'] = page+1
paginator['previous_page_number'] = page-1
return common.respond(request, user,
'values_list',
{'listing': listing,
'listing_values' : listing_values,
'paginator': paginator})
def user_page(request, username):
user = get_object_or_404(User, username=username)
query_set = user.bookmark_set.order_by('-id')
paginator = ObjectPaginator(query_set, ITEM_PER_PAGE)
is_friend = Friendship.objects.filter(
from_friend=request.user,
to_friend=user
)
try:
page = int(request.GET['page'])
except:
page = 1
try:
bookmarks = paginator.get_page(page - 1)
except:
raise Http404
variables = RequestContext(request, {
'bookmarks': bookmarks,
'username': username,
'show_tags': True,
'show_edit': username == request.user.username,
'show_paginator': paginator.pages > 1,
'has_prev': paginator.has_previous_page(page - 1),
'has_next': paginator.has_next_page(page - 1),
'page': page,
'pages': paginator.pages,
'next_page': page + 1,
'prev_page': page - 1,
'is_friend': is_friend
})
return render_to_response('user_page.html', variables)
def get(self):
page = int(self.request.get('page', '0'))
paginator = ObjectPaginator(db.GqlQuery('SELECT * FROM BlogPostModel ORDER BY created DESC'),10)
blogposts = paginator.get_page(page)
nextPageNumber = 0
prevPageNumber = 0
if paginator.has_next_page(page):
nextPageNumber = str(page+1)
if paginator.has_previous_page(page):
prevPageNumber = str(page-1)
template_values = {
'menulinks':menuLinks(),
'blogposts': blogposts,
'user': authenticatedUser(sessions.Session()),
'nextPageNumber': nextPageNumber,
'prevPageNumber': prevPageNumber,
}
path = os.path.join(os.path.dirname(__file__), 'news.html')
self.response.out.write(template.render(path, template_values))
def get(self, slug):
s = utils.lookup_agency_alias(slug)
if s:
return self.redirect('/agency/%s/' % (s))
agency = utils.get_agency(slug)
if not agency:
raise tornado.web.HTTPError(404)
messages =model.MessageAgency.all().filter('agency', agency).order('-date').fetch(1000)
paginator = ObjectPaginator(messages, 10, 1)
try:
page = int(self.get_argument('page', '1'))
except ValueError:
page = 1
if page <= 0:
page = 1
try:
records = paginator.get_page(page-1)
except:
records = paginator.get_page(0)
page = 1
self.render('agency.html', agency=agency, messages=records,
paginator=paginator,
next=paginator.has_next_page(page-1),
previous=paginator.has_previous_page(page-1),
previous_page_number=page-1,
next_page_number=page+1,
page=page)
def get(self, user):
import urllib
user = urllib.unquote(user)
if '@' in user:
u = users.User(user)
else:
u = users.User(user+'@gmail.com')
messages= model.Message.all().filter('user ='******'-date').fetch(1000)
if not messages and not users.get_current_user():
raise tornado.web.HTTPError(404)
if not messages and users.get_current_user().email() != u.email():
raise tornado.web.HTTPError(404)
paginator = ObjectPaginator(messages, 10, 1)
try:
page = int(self.get_argument('page', '1'))
except ValueError:
page = 1
try:
records = paginator.get_page(page-1)
except:
records = paginator.get_page(0)
page = 1
self.render('user.html', **{'u':u, 'messages':records, 'paginator':paginator,
"next" : paginator.has_next_page(page-1), 'previous':paginator.has_previous_page(page-1), 'previous_page_number':page-1, 'next_page_number':page+1, "page" : page})
def listMessages(page=0, page_size=10):
messages = memcache.get("message_list_%s" % (users.get_current_user()))
if not messages:
query = db.GqlQuery("SELECT * FROM Message WHERE namespace_owner = :1 ORDER BY created DESC", users.get_current_user())
messages = query.fetch((page_size * 10))
memcache.set("message_list_%s" % (users.get_current_user()), messages, (60*1))
paginator = ObjectPaginator(messages, page_size)
try:
items = paginator.get_page(page)
except InvalidPage:
raise http.Http404
options = {
"items": items,
"is_paginated": True,
"results_per_page" : page_size,
"has_next": paginator.has_next_page(page),
"has_previous": paginator.has_previous_page(page),
"page": page + 1,
"next": page + 1,
"previous": page - 1,
"pages": paginator.pages,
}
return options
def listNamespaces(page=0, page_size=10):
namespaces = memcache.get("namespace_list")
if not namespaces:
query = db.GqlQuery("SELECT * FROM Namespace WHERE owner = :1", users.get_current_user())
namespaces = query.fetch((page_size * 10))
memcache.set("namespace_list", namespaces, (60*1))
paginator = ObjectPaginator(namespaces, page_size)
try:
items = paginator.get_page(page)
except InvalidPage:
raise http.Http404
options = {
"items": items,
"is_paginated": True,
"results_per_page" : page_size,
"has_next": paginator.has_next_page(page),
"has_previous": paginator.has_previous_page(page),
"page": page + 1,
"next": page + 1,
"previous": page - 1,
"pages": paginator.pages,
}
return options
def comments(request, page):
paginator = ObjectPaginator(Comments.objects.all(), 10)
comments = paginator.get_page(page)
template_parms = {'comment_list': comments, 'comments': True}
if paginator.has_next_page(page):
template_parms['next'] = True
if paginator.has_previous_page(page):
template_parms['prev'] = True
return render_to_response('comments.html', template_parms)
def _display_common(response_dict, page, p):
paginator = ObjectPaginator(p, 20, 2)
p = paginator.get_page(page)
if not p:
raise Http404
response_dict['object_list'] = p
response_dict['page'] = page
if paginator.has_next_page(page):
response_dict['next'] = page+1
if paginator.has_previous_page(page):
response_dict['prev'] = page-1
return response_dict
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 = ObjectPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(
request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': self.paginate_by,
'has_next': paginator.has_next_page(page - 1),
'has_previous': paginator.has_previous_page(page - 1),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': paginator.last_on_page(page - 1),
'first_on_page': paginator.first_on_page(page - 1),
'pages': paginator.pages,
'hits': paginator.hits,
}, 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 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 = ObjectPaginator(queryset, self.paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and self.allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(request, {
'%s_list' % self.template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': self.paginate_by,
'has_next': paginator.has_next_page(page - 1),
'has_previous': paginator.has_previous_page(page - 1),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': paginator.last_on_page(page - 1),
'first_on_page': paginator.first_on_page(page - 1),
'pages': paginator.pages,
'hits' : paginator.hits,
}, 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 __init__(self,
queryset,
request=None,
pageno=1,
paginate_by=15,
urlprefix='',
urlnames=urlnames):
if isinstance(queryset, QuerySet):
self.queryset = queryset
else:
self.queryset = QuerysetWrapper(queryset)
self.paginate_by = paginate_by
self.request = request
self.urlprefix = urlprefix
self.urlname = urlnames
self.pageno = pageno
paginator = ObjectPaginator(self.queryset, paginate_by)
lastpage = math.ceil(1.0 * self.queryset.count() / paginate_by)
if self.request:
page = self.request.GET.get('page', 1)
else:
page = self.pageno
try:
if isinstance(page, str):
if not page.isdigit():
page = 'last'
page = lastpage
page = int(page)
if page > lastpage:
page = lastpage
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
object_list = []
self.is_paginated = paginator.pages > 1
self.results_per_page = paginate_by
self.has_next = paginator.has_next_page(page - 1)
self.has_previous = paginator.has_previous_page(page - 1)
self.page = page
self.next = page + 1
self.previous = page - 1
self.pages = paginator.pages
self.hits = paginator.hits
self.object_list = object_list
def search(request):
from django.core.paginator import ObjectPaginator, InvalidPage
from django.db.models import Q
if not request.GET:
return render_to_response('search.html', {})
q = request.GET['q'].lower()
page = int(request.GET.get('page',1))
paginate_by = 10
message = '';
# keywords = q.split()
# sql = ""
# first = True
# for word in keywords:
# if first:
# sql += "(name LIKE '%%" + word + "%%' OR description LIKE '%%" + word + "%%')"
# first = False
# else:
# sql += " AND (name LIKE '%%" + word + "%%' OR description LIKE '%%" + word + "%%')"
sql = "MATCH (name,description) AGAINST (\"%s\")" % q
# paginator=ObjectPaginator(Article.objects.extra(where=[sql]).exclude(status='P').exclude(status='N'),paginate_by)
paginator=ObjectPaginator(Article.objects.extra(where=["MATCH (name,description) AGAINST (\"%s\")"], params=[q]).exclude(status='P').exclude(status='N'),paginate_by)
# results = Article.objects.search("%s" % q).exclude(status='P').exclude(status='N')[:5]
try:
results = paginator.get_page(page-1)
except (InvalidPage, ValueError):
results = []
message = 'No results'
return render_to_response('search.html', { 'results': results, 'q': q, 'message': message,
'is_paginated': paginator.pages > 1, 'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page-1), 'has_previous':
paginator.has_previous_page(page-1), 'page': page, 'next': page + 1,
'previous': page - 1, 'pages': paginator.pages, 'hits' :
paginator.hits, } )
def __init__(self, queryset, request=None, pageno=1, paginate_by=15, urlprefix='', urlnames=urlnames):
if isinstance(queryset, QuerySet):
self.queryset = queryset
else:
self.queryset = QuerysetWrapper(queryset)
self.paginate_by = paginate_by
self.request = request
self.urlprefix = urlprefix
self.urlname = urlnames
self.pageno = pageno
paginator = ObjectPaginator(self.queryset, paginate_by)
lastpage = math.ceil(1.0*self.queryset.count()/paginate_by)
if self.request:
page = self.request.GET.get('page', 1)
else:
page = self.pageno
try:
if isinstance(page, str):
if not page.isdigit():
page = 'last'
page = lastpage
page = int(page)
if page > lastpage:
page = lastpage
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
object_list = []
self.is_paginated = paginator.pages > 1
self.results_per_page = paginate_by
self.has_next = paginator.has_next_page(page - 1)
self.has_previous = paginator.has_previous_page(page - 1)
self.page = page
self.next = page + 1
self.previous = page - 1
self.pages = paginator.pages
self.hits = paginator.hits
self.object_list = object_list
class Paginator(object):
'''
分页类 - 基于0.96版的Django paginator
@param size: 分页所含条目数
@param model: 待分页类型kind
@param query: 查询条件字符串，如：WHERE name = 'cyndia'
@param nu: 客户端提交的页码
'''
def __init__(self, size, entries, nu):
'''
@param size: 分页所含条目数
@param model: 待分页类型kind
@param nu: 客户端提交的页码
@var number: 当前页码
@var paginator: 分页器
@var total: 总页数
@var entries: 分页条目
@var list: 页数列表
'''
self.number = self.get_number(nu)
self.paginator = ObjectPaginator(entries, size)
self.total = self.paginator.pages
self.entries = self.get_entries(int(self.number - 1), self.total)
self.list = self.get_page_list(self.total)
def get_number(self, nu):
'''
验证客户端提交页码
@return: 页码x 或者 1
'''
try:
return int(nu)
except:
return 1
def is_paginator(self):
'''
是否可分页
@return: True/False
'''
if self.total > 1:
return True
else:
return False
def get_entries(self, nu, total):
'''
获取内容
@return: 内容
'''
try:
entries = self.paginator.get_page(nu)
except InvalidPage:
entries = self.paginator.get_page(int(total - 1))
return entries
def has_previous_page(self):
'''
是否存在上一页
@return: True/False
'''
if self.paginator.has_previous_page(self.number - 1):
return True
else:
return False
def has_next_page(self):
'''
是否存在下一页
@return: True/False
'''
if self.paginator.has_next_page(self.number - 1):
return True
else:
return False
def get_page_list(self, total):
'''
获取页数列表
@return: 列表'''
if self.is_paginator():
return [i for i in range(1, total + 1)]
def view_row_level_permissions(request, app_label, model_name, object_id):
"""
Displays a list of row level permisisons for the model instance
"""
model = models.get_model(app_label, model_name)
object_id = unquote(object_id)
model_ct = ContentType.objects.get_for_model(model)
model_instance = get_object_or_404(model, pk=object_id)
opts = model_instance._meta
if not opts.row_level_permissions:
raise Http404
if not request.user.has_perm(opts.app_label + "." + opts.get_change_permission(), object=model_instance):
raise PermissionDenied
if not (
request.user.has_perm(
RowLevelPermission._meta.app_label + "." + RowLevelPermission._meta.get_change_permission()
)
or request.user.has_perm(
RowLevelPermission._meta.app_label + "." + RowLevelPermission._meta.get_add_permission()
)
):
raise PermissionDenied
c = template.RequestContext(
request,
{
"title": _("Edit Row Level Permissions"),
"object_id": object_id,
"content_type_id": model_ct.id,
"original": model_instance,
"opts": opts,
},
)
# Set up the paging
list_per_page = RowLevelPermission._meta.admin.list_per_page
paginator = ObjectPaginator(model_instance.row_level_permissions.order_by("owner_ct", "owner_id"), list_per_page)
page = int(request.GET.get("page", 1)) - 1
try:
rlp_list = paginator.get_page(page)
except InvalidPage:
rlp_list = []
paginator_context = {
"is_paginated": paginator.has_next_page(0),
"has_next": paginator.has_next_page(page),
"has_previous": paginator.has_previous_page(page),
"page": page + 1,
"next": page + 2,
"previous": page,
"hits": paginator.hits,
"results_per_page": list_per_page,
"pages": paginator.pages,
"has_next": paginator.has_next_page(page),
"has_previous": paginator.has_previous_page(page),
}
c.update(paginator_context)
rlp_errors = rlp_new_data = {}
add_rlp_manip = AddRLPManipulator(model_instance, model_ct)
edit_rlp_manip = ChangeRLPManipulator(model_ct)
new_rlp_form = forms.FormWrapper(add_rlp_manip, rlp_new_data, rlp_errors)
# 3 different groups of forms when split by owner
user_rlp_form_list = []
other_rlp_form_list = []
group_rlp_form_list = []
group_ct = model_ct = ContentType.objects.get_for_model(Group)
user_ct = model_ct = ContentType.objects.get_for_model(User)
for r in rlp_list:
owner_val = MultipleObjSelectField.returnKey(r.owner, r.owner_ct)
data = {"id": r.id, "owner": owner_val, "perm": r.permission.id, "negative": r.negative}
if r.owner_ct.id == user_ct.id:
user_rlp_form_list.append({"form": forms.FormWrapper(edit_rlp_manip, data, rlp_errors), "rlp": r})
elif r.owner_ct.id == group_ct.id:
group_rlp_form_list.append({"form": forms.FormWrapper(edit_rlp_manip, data, rlp_errors), "rlp": r})
else:
other_rlp_form_list.append({"form": forms.FormWrapper(edit_rlp_manip, data, rlp_errors), "rlp": r})
# Combine together the three kinds
rlp_forms = []
if user_rlp_form_list:
rlp_forms.append((_("Users"), user_rlp_form_list))
if group_rlp_form_list:
rlp_forms.append((_("Groups"), group_rlp_form_list))
if other_rlp_form_list:
rlp_forms.append((_("Other"), other_rlp_form_list))
rlp_context = {"new_rlp_form": new_rlp_form, "rlp_forms": rlp_forms}
c.update(rlp_context)
return render_to_response(
[
"admin/%s/%s/row_level_permission.html" % (opts.app_label, opts.object_name.lower()),
"admin/%s/row_level_permission.html" % opts.app_label,
"admin/row_level_permission.html",
],
context_instance=c,
)
def get(self):
self.session = Session()
if CheckAuth(self) is False:
return DoAuth(self, '/writer/overview')
site_domain = Datum.get('site_domain')
site_domain_sync = Datum.get('site_domain_sync')
site_name = Datum.get('site_name')
site_author = Datum.get('site_author')
site_slogan = Datum.get('site_slogan')
site_analytics = Datum.get('site_analytics')
if site_domain is None:
site_domain = os.environ['HTTP_HOST']
Datum.set('site_domain', os.environ['HTTP_HOST'])
if site_domain_sync is None:
site_domain_sync = os.environ['HTTP_HOST']
Datum.set('site_domain_sync', os.environ['HTTP_HOST'])
articles = memcache.get('writer_articles')
if articles is None:
articles = Article.all().order('-created')
memcache.set('writer_articles', articles, 86400)
paginator = ObjectPaginator(articles, PAGE_SIZE)
try:
page = int(self.request.get('page', 0))
articles = paginator.get_page(page)
except InvalidPage:
articles = paginator.get_page(int(paginator.pages - 1))
if paginator.pages > 1:
is_paginated = True
else:
is_paginated = False
if site_domain is None or site_name is None or site_author is None:
site_configured = False
else:
site_configured = True
if is_paginated:
self.session['page'] = page
urls = memcache.get('writer_urls')
if urls is None:
everything = Article.all().order('-title_url')
urls = []
for article in everything:
urls.append(article.title_url)
memcache.set('writer_urls', urls, 86400)
template_values = {
'site_configured' : site_configured,
'is_paginated' : is_paginated,
'page_size' : PAGE_SIZE,
'page_has_next' : paginator.has_next_page(page),
'page_has_previous' : paginator.has_previous_page(page),
'page' : page,
'next' : page + 1,
'previous' : page - 1,
'pages' : paginator.pages,
'articles' : articles,
'articles_total' : len(articles),
'page_range' : range(0, paginator.pages),
'urls' : urls
}
if site_analytics is not None:
template_values['site_analytics'] = site_analytics
if site_domain_sync is None:
q = site_domain
else:
q = site_domain + ' OR ' + site_domain_sync
mentions_web = memcache.get('mentions_web')
if mentions_web is None:
try:
mentions_web = feedparser.parse('http://blogsearch.google.com/blogsearch_feeds?hl=en&q=' + urllib.quote('link:' + Datum.get('site_domain')) + '&ie=utf-8&num=10&output=atom')
memcache.add('mentions_web', mentions_web, 3600)
except:
mentions_web = None
if mentions_web is not None:
template_values['mentions_web'] = mentions_web.entries
# mentions_twitter = memcache.get('mentions_twitter')
# if mentions_twitter is None:
# try:
# result = urlfetch.fetch(TWITTER_API_ROOT + 'search.json?q=' + urllib.quote(q))
# if result.status_code == 200:
# mentions_twitter = simplejson.loads(result.content)
# memcache.add('mentions_twitter', mentions_twitter, 3600)
# except:
# mentions_twitter = None
# if mentions_twitter is not None:
# if len(mentions_twitter['results']) > 0:
# template_values['mentions_twitter'] = mentions_twitter['results']
template_values['system_version'] = VERSION
path = os.path.join(os.path.dirname(__file__), 'tpl', 'writer', 'overview.html')
self.response.out.write(template.render(path, template_values))
def object_list(request, app_label, module_name, paginate_by=None, allow_empty=False,
template_name=None, template_loader=template_loader,
extra_lookup_kwargs={}, extra_context={}):
"""
Generic list of objects.
Templates: ``<app_label>/<module_name>_list``
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
"""
mod = models.get_module(app_label, module_name)
lookup_kwargs = extra_lookup_kwargs.copy()
if paginate_by:
paginator = ObjectPaginator(mod, lookup_kwargs, paginate_by)
page = request.GET.get('page', 0)
try:
object_list = paginator.get_page(page)
except InvalidPage:
if page == 0 and allow_empty:
object_list = []
else:
raise Http404
page = int(page)
c = Context(request, {
'object_list': object_list,
'is_paginated': True,
'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page),
'has_previous': paginator.has_previous_page(page),
'page': page + 1,
'next': page + 1,
'previous': page - 1,
'pages': paginator.pages,
'hits' : paginator.hits,
})
else:
object_list = mod.get_list(**lookup_kwargs)
c = Context(request, {
'object_list': object_list,
'is_paginated': False
})
if len(object_list) == 0 and not allow_empty:
raise Http404
for key, value in extra_context.items():
if callable(value):
c[key] = value()
else:
c[key] = value
if not template_name:
template_name = "%s/%s_list" % (app_label, module_name)
t = template_loader.get_template(template_name)
return HttpResponse(t.render(c))
def everyones_kwips(request):
from django.db import connection
cursor = connection.cursor()
page = int(request.GET.get('page',0))
paginate_by = 10
quips_for ='everyone'
if request.user.is_authenticated():
user_login=request.user.username
else:
user_login = '******'
# cursor.execute("select kwippy_quip.id from kwippy_quip,kwippy_account where kwippy_account.id=kwippy_quip.account_id and kwippy_quip.repeat_id in (kwippy_quip.id,0) and kwippy_quip.formated not in ('Away','Available','Logged Out') and kwippy_account.user_id>0 order by id desc limit 1000")
cursor.execute("select id from kwippy_quip where repeat_id in (id,0) and formated not in ('Away','Available','Logged Out')and account_id in (select id from kwippy_account where status=1 and user_id>0) order by id desc limit 1000")
quip_ids = [item[0] for item in cursor.fetchall()]
quips = Quip.objects.filter(id__in=quip_ids).order_by('-created_at')
#cursor.execute(
#"select distinct(account_id) from kwippy_quip order by id desc limit 100")
##"select distinct(q.account_id) from kwippy_quip q, kwippy_account a where a.id=q.account_id and a.user_id>1 order by q.created_at desc limit 100")
#account_ids = [int(item[0]) for item in cursor.fetchall()]
#quips = Quip.objects.filter(id=0)
#for acc_id in account_ids:
#cursor.execute("select * from kwippy_quip where account_id = %d order by created_at desc limit 1" % (acc_id))
#quip_id = [item[0] for item in cursor.fetchall()]
#kwip = Quip.objects.filter(id=int(quip_id[0]))
#quips = quips | kwip
#quips = quips.order_by('-created_at')
#quips = Quip.objects.all().exclude(original='I'm not here right now').order_by('-created_at')[:100]
dict = details_for_kwips_page(request,user_login)
paginator = ObjectPaginator(quips, paginate_by)
quips = paginator.get_page(page)
return render_to_response('mypage.html', {'is_paginated': paginator.pages > 1, 'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page), 'has_previous': paginator.has_previous_page(page),
'page': page + 1, 'next': page + 1, 'previous': page - 1, 'pages': paginator.pages,
'hits' : paginator.hits, 'login': user_login,'user_profile': dict['user_profile'],'quips': quips,
'users_followees': dict['users_followees'], 'users_followers': dict['users_followers'], 'displayname': dict['displayname'],
'followees_count':dict['followees_count'], 'followers_count':dict['followers_count'], 'is_receiver_following':dict['is_receiver_following'],
'quips_for': quips_for,'is_following': dict['is_following'],'is_following_on_im': dict['is_following_on_im'],
'logged_in_user_profile': dict['logged_in_user_profile'], 'profile_for_display': dict['profile_for_display'],'favs_count':dict['favs_count'],
'kwip_count':kwip_count(dict['user']),'comment_count':comment_count(dict['user']),
'revision_number': settings.REVISION_NUMBER,}, context_instance=template.RequestContext(request))
def filtered_kwips_page(request,user_login,year,month=0,day=0,hour=0,serial=0,filter_by='day',with_reply_box=False):
is_single = False
paginate_by = 10
dict = details_for_kwips_page(request,user_login)
month_in_words = ['jan','feb','mar','apr','may','jun','jul','aug','sep','oct','nov','dec']
i=1
for mon in month_in_words:
if month==mon:
month=i
i=i+1
#getting all accounts for user
accounts = Account.objects.filter(user=dict['user'],status=1)
if accounts:
accounts_list_in_csv = queryset_to_csv(accounts,'account')
if filter_by=='year':
quips = Quip.objects.filter(account__in=accounts_list_in_csv,created_at__year=int(year)).order_by('-created_at')
elif filter_by=='month':
quips = Quip.objects.filter(account__in=accounts_list_in_csv,created_at__year=int(year),created_at__month=int(month)).order_by('-created_at')
elif filter_by=='date':
quips = Quip.objects.filter(account__in=accounts_list_in_csv,created_at__year=int(year),created_at__month=int(month),created_at__day=int(day)).order_by('-created_at')
elif filter_by=='hour':
quips = quip_for_a_time(dict['user'],filter_by,year,month,day,hour)
elif filter_by=='minute':
minute=hour[2]+hour[3]
hour = hour[0]+hour[1]
quips = quip_for_a_time(dict['user'],filter_by,year,month,day,int(hour),int(minute))
elif filter_by=='second':
second=hour[4]+hour[5]
minute=hour[2]+hour[3]
hour = hour[0]+hour[1]
quips = quip_for_a_time(dict['user'],filter_by,year,month,day,int(hour),int(minute),int(second))
if len(quips)==1:
is_single=True
elif filter_by=='single':
second=hour[4]+hour[5]
minute=hour[2]+hour[3]
hour = hour[0]+hour[1]
quipsnow = quip_for_a_time(dict['user'],filter_by,year,month,day,int(hour),int(minute),int(second))
is_single=True
for q in quipsnow:
quips = q.quips_on_same_time_serial(int(serial))
#break commented by MD
paginator = ObjectPaginator(quips, paginate_by)
page = int(request.GET.get('page',0))
quips = paginator.get_page(page)
return render_to_response('mypage.html', {'is_paginated': paginator.pages > 1, 'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page), 'has_previous': paginator.has_previous_page(page),
'page': page + 1, 'next': page + 1, 'previous': page - 1, 'pages': paginator.pages, 'is_following': dict['is_following'],'is_following_on_im': dict['is_following_on_im'],
'hits' : paginator.hits, 'login': user_login,'user_profile': dict['user_profile'],'quips': quips,'is_receiver_following':dict['is_receiver_following'],
'users_followees': dict['users_followees'], 'users_followers': dict['users_followers'], 'profile_for_display': dict['profile_for_display'],
'followees_count':dict['followees_count'], 'followers_count':dict['followers_count'],'displayname': dict['displayname'],'favs_count':dict['favs_count'],
'quips_for': 'self','with_reply_box':with_reply_box,'is_single':is_single,
'kwip_count':kwip_count(dict['user']),'comment_count':comment_count(dict['user'])},context_instance=template.RequestContext(request))
def mypage(request,user_login,quips_for):
cursor = connection.cursor()
page = int(request.GET.get('page',0))
if request.GET.get('page') and page==0:
if quips_for=='all':
return HttpResponseRedirect('/'+user_login+'/')
else:
return HttpResponseRedirect('/'+user_login+'/'+'kwips/')
paginate_by = 10
login_user = get_object_or_404(User, username=user_login)
#ques = fb_question_for_page(request.user,'mypage')
dict = details_for_kwips_page(request,user_login)
if quips_for=='self':
accounts = Account.objects.filter(user=dict['user'],status=1)
if accounts:
show_repeat = get_object_or_404(PageSetting, user=login_user).show_repeat
if show_repeat==1:
#accounts_list_in_csv = queryset_to_csv(accounts,'account')
cursor.execute("select kwippy_quip.id from kwippy_quip,kwippy_account where kwippy_account.id=kwippy_quip.account_id and kwippy_account.user_id=%s and kwippy_account.status=1 and kwippy_quip.formated not in ('Away','Available','Logged Out') order by id desc limit 1000", (login_user.id,))
quip_ids = [item[0] for item in cursor.fetchall()]
#quips = Quip.objects.filter(account__in=accounts_list_in_csv).exclude(original='Away').order_by('-created_at')
quips = Quip.objects.filter(id__in=quip_ids).order_by('-created_at')
#quips = Quip.objects.extra(where=['account_id IN %s','repeat_id=id'],params=[(accounts_list_in_csv)]).order_by('-created_at')
else:
#accounts_list_in_csv = queryset_to_csv(accounts,'account_forsql')
#cursor.execute("SELECT * FROM kwippy_quip WHERE account_id in (%s) and repeat_id in (id,0) and formated not in ('Away','Idle' )" % ( accounts_list_in_csv))
cursor.execute("select kwippy_quip.id from kwippy_quip,kwippy_account where kwippy_account.id=kwippy_quip.account_id and kwippy_account.user_id=%s and kwippy_account.status=1 and kwippy_quip.repeat_id in (kwippy_quip.id,0) and kwippy_quip.formated not in ('Away','Available','Logged Out') order by id desc limit 1000", (login_user.id,))
quip_ids = [item[0] for item in cursor.fetchall()]
quips = Quip.objects.filter(id__in=quip_ids).order_by('-created_at')
elif quips_for=='all':
#quips=Quip.objects.filter(id=0)
#for item in dict['followees']:
#accounts=Account.objects.filter(user=item.followee)
#q1=Quip.objects.filter(account__in=accounts, created_at__gt=item.created_at).order_by('-created_at')
#quips=quips|q1
##adding kwips for the logged in user to the queryset
#accounts=Account.objects.filter(user=dict['user'])
#quips = quips | Quip.objects.filter(account__in=accounts).order_by('-created_at')
#followees_list_in_csv = queryset_to_csv(dict['followees'],'followee')
#accounts = Account.objects.filter(user__in=followees_list_in_csv,status=1)
#accounts = accounts | Account.objects.filter(user=dict['user'])
#accounts_list_in_csv = queryset_to_csv(accounts,'account_forsql')
#cursor.execute("SELECT * FROM kwippy_quip WHERE account_id in (%s) and repeat_id in (id,0) and formated not in ('Away','Idle')" % ( accounts_list_in_csv))
#cursor.execute("select kwippy_quip.id from kwippy_quip,kwippy_account where kwippy_account.id=kwippy_quip.account_id and kwippy_quip.repeat_id in (kwippy_quip.id,0) and kwippy_quip.formated not in ('Away','Available','Logged Out') and kwippy_account.user_id in (select follower_id from kwippy_follower where followee_id=%s) union select kwippy_quip.id from kwippy_quip,kwippy_account where kwippy_account.id=kwippy_quip.account_id and kwippy_account.user_id=%s order by id desc limit 1000", (login_user.id,login_user.id,))
cursor.execute("select id from kwippy_quip where repeat_id in (id,0) and formated not in ('Away','Available','Logged Out') and account_id in (select id from kwippy_account where status=1 and user_id in (select followee_id from kwippy_follower where follower_id=%s) union select id from kwippy_account where user_id=%s) order by id desc limit 1000", (login_user.id,login_user.id,))
quip_ids = [item[0] for item in cursor.fetchall()]
quips = Quip.objects.filter(id__in=quip_ids).order_by('-created_at')
if quips:
paginator = ObjectPaginator(quips, paginate_by)
quips = paginator.get_page(page)
return render_to_response('mypage.html', {'is_paginated': paginator.pages > 1, 'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page), 'has_previous': paginator.has_previous_page(page),
'page': page + 1, 'next': page + 1, 'previous': page - 1, 'pages': paginator.pages,
'hits' : paginator.hits, 'login': user_login,'user_profile': dict['user_profile'],'quips': quips,'favs_count':dict['favs_count'],
'users_followees': dict['users_followees'], 'users_followers': dict['users_followers'], 'displayname': dict['displayname'],
'followees_count':dict['followees_count'], 'followers_count':dict['followers_count'],'is_receiver_following':dict['is_receiver_following'],
'quips_for': quips_for,'is_following': dict['is_following'],'is_following_on_im': dict['is_following_on_im'],
'logged_in_user_profile': dict['logged_in_user_profile'], 'profile_for_display': dict['profile_for_display'],
'revision_number': settings.REVISION_NUMBER,
'kwip_count':kwip_count(dict['user']),'comment_count':comment_count(dict['user'])}, context_instance=template.RequestContext(request))
else:
return render_to_response('mypage.html', {'login': user_login,'user_profile': dict['user_profile'],
'users_followees': dict['users_followees'], 'users_followers': dict['users_followers'],
'followees_count':dict['followees_count'], 'followers_count':dict['followers_count'], 'displayname': dict['displayname'],
'quips_for': quips_for,'is_following': dict['is_following'],'is_following_on_im': dict['is_following_on_im'],'favs_count':dict['favs_count'],
'logged_in_user_profile': dict['logged_in_user_profile'], 'profile_for_display': dict['profile_for_display'],
'revision_number': settings.REVISION_NUMBER,'is_receiver_following':dict['is_receiver_following'],
'kwip_count':kwip_count(dict['user']),'comment_count':comment_count(dict['user'])}, context_instance=template.RequestContext(request))
def has_previous_page(self, page_num=None):
if page_num is None:
return ObjectPaginator.has_previous_page(self, self.current_page - 1)
else:
return ObjectPaginator.has_previous_page(self, page_num)
def previous_link(self):
if ObjectPaginator.has_previous_page(self, self.current_page - 1):
return self.link_template % (self.current_page - 1)
else:
return None
def get(self):
self.session = Session()
if CheckAuth(self) is False:
return DoAuth(self, '/writer/overview')
site_domain = Datum.get('site_domain')
site_domain_sync = Datum.get('site_domain_sync')
site_name = Datum.get('site_name')
site_author = Datum.get('site_author')
site_slogan = Datum.get('site_slogan')
site_analytics = Datum.get('site_analytics')
if site_domain is None:
site_domain = os.environ['HTTP_HOST']
Datum.set('site_domain', os.environ['HTTP_HOST'])
if site_domain_sync is None:
site_domain_sync = os.environ['HTTP_HOST']
Datum.set('site_domain_sync', os.environ['HTTP_HOST'])
articles = memcache.get('writer_articles')
if articles is None:
articles = Article.all().order('-created')
memcache.set('writer_articles', articles, 86400)
paginator = ObjectPaginator(articles, PAGE_SIZE)
try:
page = int(self.request.get('page', 0))
articles = paginator.get_page(page)
except InvalidPage:
articles = paginator.get_page(int(paginator.pages - 1))
if paginator.pages > 1:
is_paginated = True
else:
is_paginated = False
if site_domain is None or site_name is None or site_author is None:
site_configured = False
else:
site_configured = True
if is_paginated:
self.session['page'] = page
urls = memcache.get('writer_urls')
if urls is None:
everything = Article.all().order('-title_url')
urls = []
for article in everything:
urls.append(article.title_url)
memcache.set('writer_urls', urls, 86400)
template_values = {
'site_configured': site_configured,
'is_paginated': is_paginated,
'page_size': PAGE_SIZE,
'page_has_next': paginator.has_next_page(page),
'page_has_previous': paginator.has_previous_page(page),
'page': page,
'next': page + 1,
'previous': page - 1,
'pages': paginator.pages,
'articles': articles,
'articles_total': len(articles),
'page_range': range(0, paginator.pages),
'urls': urls
}
if site_analytics is not None:
template_values['site_analytics'] = site_analytics
if site_domain_sync is None:
q = site_domain
else:
q = site_domain + ' OR ' + site_domain_sync
mentions_web = memcache.get('mentions_web')
if mentions_web is None:
try:
mentions_web = feedparser.parse(
'http://blogsearch.google.com/blogsearch_feeds?hl=en&q=' +
urllib.quote('link:' + Datum.get('site_domain')) +
'&ie=utf-8&num=10&output=atom')
memcache.add('mentions_web', mentions_web, 600)
except:
mentions_web = None
if mentions_web is not None:
template_values['mentions_web'] = mentions_web.entries
mentions_twitter = memcache.get('mentions_twitter')
if mentions_twitter is None:
try:
result = urlfetch.fetch(TWITTER_API_ROOT + 'search.json?q=' +
urllib.quote(q))
if result.status_code == 200:
mentions_twitter = simplejson.loads(result.content)
memcache.add('mentions_twitter', mentions_twitter, 600)
except:
mentions_twitter = None
if mentions_twitter is not None:
if len(mentions_twitter['results']) > 0:
template_values['mentions_twitter'] = mentions_twitter[
'results']
template_values['system_version'] = VERSION
if 'message' in self.session:
template_values['message'] = self.session['message']
del self.session['message']
path = os.path.join(os.path.dirname(__file__), 'tpl', 'writer',
'overview.html')
self.response.out.write(template.render(path, template_values))
class Paginator(object):
"""
Much like Django's ``ObjectPaginator`` (which it uses), but always
represents a specific current page instead of just providing an interface
to the data. Based on the active page it makes a number of properties
available which mostly work exactly like the context that the
``object_list`` generic view provides.
``__init__`` takes the same arguments as ``ObjectPaginator``, plus an
additional parameter ``page`` to initialize the active page number. It does
not need to be an int, i.e. it can come directly from ``request.GET``; if
conversion to an integer fails, a ``Http404`` exception is raised.
You can also later assign to to ``page`` attribute.
>>> items = range(1,6789)
>>> paginator = Paginator(items, num_per_page=10, page=3)
>>> paginator.items
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
>>> paginator.is_paginated
True
>>> paginator.results_per_page
10
>>> paginator.has_next
True
>>> paginator.has_previous
True
>>> paginator.page
3
>>> paginator.page0
2
>>> paginator.next
4
>>> paginator.previous
2
>>> paginator.last_on_page
30
>>> paginator.first_on_page
21
>>> paginator.pages
679
>>> paginator.hits
6788
"""
def __init__(self, *args, **kwargs):
page = kwargs.pop('page', 1)
self._paginator = DjangoPaginator(*args, **kwargs)
# Resolve the page number; this is similar to what the Django
# ``object_list`` generic view is doing.
try:
self.page = int(page)
except ValueError:
if page == 'last': self.page = self._paginator.pages
else: raise Http404
def _set_page(self, new_page):
self.__page = new_page
try:
self.object_list = self._paginator.get_page(new_page-1)
except InvalidPage:
if new_page != -1: raise Http404
else: self.object_list = [] # allow empty
self.items = self.object_list # alias
# update all exposed info for the new page number
self.update_attrs()
def _get_page(self): return self.__page
page = property(_get_page, _set_page)
def update_attrs(self):
"""Override in descendants to set custom fields."""
self.page0 = self.page-1
self.is_paginated = self._paginator.pages > 1
self.results_per_page = self._paginator.num_per_page
self.has_next = self._paginator.has_next_page(self.page-1)
self.has_previous = self._paginator.has_previous_page(self.page-1)
self.next = self.page+1
self.previous = self.page-1
self.last_on_page = self._paginator.last_on_page(self.page-1)
self.first_on_page = self._paginator.first_on_page(self.page-1)
self.pages = self._paginator.pages
self.hits = self._paginator.hits
self.page_range = self._paginator.page_range
def object_list(request,
queryset,
paginate_by=None,
page=None,
allow_empty=False,
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)
"""
if extra_context is None: extra_context = {}
queryset = queryset._clone()
if paginate_by:
paginator = ObjectPaginator(queryset, paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
object_list = paginator.get_page(page - 1)
except (InvalidPage, ValueError):
if page == 1 and allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(
request, {
'%s_list' % template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page - 1),
'has_previous': paginator.has_previous_page(page - 1),
'page': page,
'next': page + 1,
'previous': page - 1,
'last_on_page': paginator.last_on_page(page - 1),
'first_on_page': paginator.first_on_page(page - 1),
'pages': paginator.pages,
'hits': paginator.hits,
}, context_processors)
else:
c = RequestContext(request, {
'%s_list' % template_object_name: queryset,
'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 main(request,fb_for='all'):
if request.user.is_superuser:
page = int(request.GET.get('page',0))
paginate_by = 10
if fb_for=='self':
feedback = Feedback.objects.filter(user=request.user).order_by('-created_at')
elif fb_for=='all':
feedback = Feedback.objects.all().order_by('-created_at')
paginator = ObjectPaginator(feedback, paginate_by)
feedback = paginator.get_page(page)
return render_to_response('fb.html', {'is_paginated': paginator.pages > 1, 'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page), 'has_previous': paginator.has_previous_page(page),
'page': page + 1, 'next': page + 1, 'previous': page - 1, 'pages': paginator.pages,
'hits' : paginator.hits,'quips': feedback,'quips_for': fb_for,},
context_instance=template.RequestContext(request))
else:
return HttpResponseRedirect('/'+request.user.username+'/')
#sweating by still coding :)
def get(self):
self.session = Session()
if CheckAuth(self) is False:
return DoAuth(self, "/writer/overview")
site_domain = Datum.get("site_domain")
site_domain_sync = Datum.get("site_domain_sync")
site_name = Datum.get("site_name")
site_author = Datum.get("site_author")
site_slogan = Datum.get("site_slogan")
site_analytics = Datum.get("site_analytics")
if site_domain is None:
site_domain = os.environ["HTTP_HOST"]
Datum.set("site_domain", os.environ["HTTP_HOST"])
if site_domain_sync is None:
site_domain_sync = os.environ["HTTP_HOST"]
Datum.set("site_domain_sync", os.environ["HTTP_HOST"])
articles = memcache.get("writer_articles")
if articles is None:
articles = Article.all().order("-created")
memcache.set("writer_articles", articles, 86400)
paginator = ObjectPaginator(articles, PAGE_SIZE)
try:
page = int(self.request.get("page", 0))
articles = paginator.get_page(page)
except InvalidPage:
articles = paginator.get_page(int(paginator.pages - 1))
if paginator.pages > 1:
is_paginated = True
else:
is_paginated = False
if site_domain is None or site_name is None or site_author is None:
site_configured = False
else:
site_configured = True
if is_paginated:
self.session["page"] = page
urls = memcache.get("writer_urls")
if urls is None:
everything = Article.all().order("-title_url")
urls = []
for article in everything:
urls.append(article.title_url)
memcache.set("writer_urls", urls, 86400)
template_values = {
"site_configured": site_configured,
"is_paginated": is_paginated,
"page_size": PAGE_SIZE,
"page_has_next": paginator.has_next_page(page),
"page_has_previous": paginator.has_previous_page(page),
"page": page,
"next": page + 1,
"previous": page - 1,
"pages": paginator.pages,
"articles": articles,
"articles_total": len(articles),
"page_range": range(0, paginator.pages),
"urls": urls,
}
if site_analytics is not None:
template_values["site_analytics"] = site_analytics
if site_domain_sync is None:
q = site_domain
else:
q = site_domain + " OR " + site_domain_sync
mentions_web = memcache.get("mentions_web")
if mentions_web is None:
try:
mentions_web = feedparser.parse(
"http://blogsearch.google.com/blogsearch_feeds?hl=en&q="
+ urllib.quote("link:" + Datum.get("site_domain"))
+ "&ie=utf-8&num=10&output=atom"
)
memcache.add("mentions_web", mentions_web, 600)
except:
mentions_web = None
if mentions_web is not None:
template_values["mentions_web"] = mentions_web.entries
# mentions_twitter = memcache.get('mentions_twitter')
# if mentions_twitter is None:
# try:
# result = urlfetch.fetch('http://search.twitter.com/search.json?q=' + urllib.quote(q))
# if result.status_code == 200:
# mentions_twitter = simplejson.loads(result.content)
# memcache.add('mentions_twitter', mentions_twitter, 600)
# except:
# mentions_twitter = None
# if mentions_twitter is not None:
# if len(mentions_twitter['results']) > 0:
# template_values['mentions_twitter'] = mentions_twitter['results']
template_values["system_version"] = VERSION
if "message" in self.session:
template_values["message"] = self.session["message"]
del self.session["message"]
path = os.path.join(os.path.dirname(__file__), "tpl", "writer", "overview.html")
self.response.out.write(template.render(path, template_values))
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 = ObjectPaginator(queryset, paginate_by)
if not page:
page = request.GET.get('page', 1)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.pages
else:
# Page is not 'last', nor can it be converted to an int
raise Http404
try:
object_list = paginator.get_page(page_number - 1)
except InvalidPage:
if page_number == 1 and allow_empty:
object_list = []
else:
raise Http404
c = RequestContext(request, {
'%s_list' % template_object_name: object_list,
'is_paginated': paginator.pages > 1,
'results_per_page': paginate_by,
'has_next': paginator.has_next_page(page_number - 1),
'has_previous': paginator.has_previous_page(page_number - 1),
'page': page_number,
'next': page_number + 1,
'previous': page_number - 1,
'last_on_page': paginator.last_on_page(page_number - 1),
'first_on_page': paginator.first_on_page(page_number - 1),
'pages': paginator.pages,
'hits' : paginator.hits,
'page_range' : paginator.page_range
}, context_processors)
else:
c = RequestContext(request, {
'%s_list' % template_object_name: queryset,
'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)