Navigation
==========
-The navigation system is based on a django context called NavContext,
-implemented in pgweb.util.contexts.NavContext. This means that all the
+The navigation system is based on a django function called render_pgweb,
+implemented in pgweb.util.contexts. This means that all the
menu links in the system are defined in this file
-(pgweb/utils/contexts.py). Each django view needs to specify the
-NavContext in it's call to template rendering, and this will make the
-correct nav menu show up.
+(pgweb/utils/contexts.py). Each django view needs to use render_pgweb()
+instead of render(), and this will make the correct nav menu show up.
This is one of the parts of the system that can probably be made a lot
easier, leaving much room for future improvement :-)
from django.contrib.auth import login as django_login
import django.contrib.auth.views as authviews
from django.http import HttpResponseRedirect, Http404, HttpResponse
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
from pgweb.util.decorators import login_required
from django.utils.encoding import force_bytes
from django.utils.http import urlsafe_base64_encode
from datetime import datetime, timedelta
import itertools
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.misc import send_template_mail, generate_random_token, get_client_ip
from pgweb.util.helpers import HttpServerError
myorgs = Organisation.objects.filter(managers=request.user, approved=False)
myproducts = Product.objects.filter(org__managers=request.user, approved=False)
myprofservs = ProfessionalService.objects.filter(org__managers=request.user, approved=False)
- return render_to_response('account/index.html', {
+ return render_pgweb(request, 'account', 'account/index.html', {
'newsarticles': myarticles,
'events': myevents,
'organisations': myorgs,
'products': myproducts,
'profservs': myprofservs,
- }, NavContext(request, 'account'))
+ })
objtypes = {
'news': {
if contrib:
contribform = ContributorForm(instance=contrib)
- return render_to_response('account/userprofileform.html', {
+ return render_pgweb(request, 'account', 'account/userprofileform.html', {
'userform': userform,
'profileform': profileform,
'contribform': contribform,
'can_change_email': can_change_email,
- }, NavContext(request, "account"))
+ })
@login_required
@transaction.atomic
else:
form = ChangeEmailForm(request.user)
- return render_to_response('account/emailchangeform.html', {
+ return render_pgweb(request, 'account', 'account/emailchangeform.html', {
'form': form,
'token': token,
- }, NavContext(request, "account"))
+ })
@login_required
@transaction.atomic
request.user.save()
token.delete()
- return render_to_response('account/emailchangecompleted.html', {
+ return render_pgweb(request, 'account', 'account/emailchangecompleted.html', {
'token': tokenhash,
'success': token and True or False,
- }, NavContext(request, "account"))
+ })
@login_required
def listobjects(request, objtype):
raise Http404("Object type not found")
o = objtypes[objtype]
- return render_to_response('account/objectlist.html', {
+ return render_pgweb(request, 'account', 'account/objectlist.html', {
'objects': o['objects'](request.user),
'title': o['title'],
'submit_header': o.has_key('submit_header') and o['submit_header'] or None,
'suburl': objtype,
- }, NavContext(request, 'account'))
+ })
@login_required
def orglist(request):
orgs = Organisation.objects.filter(approved=True)
- return render_to_response('account/orglist.html', {
+ return render_pgweb(request, 'account', 'account/orglist.html', {
'orgs': orgs,
- }, NavContext(request, 'account'))
+ })
def login(request):
return authviews.login(request, template_name='account/login.html',
else:
form = SignupForm(get_client_ip(request))
- return render_to_response('base/form.html', {
+ return render_pgweb(request, 'account', 'base/form.html', {
'form': form,
'formitemtype': 'Account',
'form_intro': """
'savebutton': 'Sign up',
'operation': 'New',
'recaptcha': True,
- }, NavContext(request, 'account'))
+ })
def signup_complete(request):
- return render_to_response('account/signup_complete.html', {
- }, NavContext(request, 'account'))
+ return render_pgweb(request, 'account', 'account/signup_complete.html', {
+ })
@transaction.atomic
'last_name': request.session['oauth_lastname'][:30],
})
- return render_to_response('account/signup_oauth.html', {
+ return render_pgweb(request, 'account', 'account/signup_oauth.html', {
'form': form,
'operation': 'New account',
'savebutton': 'Sign up for new account',
'recaptcha': True,
- }, NavContext(request, 'account'))
+ })
####
## Community authentication endpoint
# course, we fill a structure with information about the user.
if request.user.first_name=='' or request.user.last_name=='' or request.user.email=='':
- return render_to_response('account/communityauth_noinfo.html', {
- }, NavContext(request, 'account'))
+ return render_pgweb(request, 'account', 'account/communityauth_noinfo.html', {
+ })
# Check for cooloff period
if site.cooloff_hours > 0:
if (datetime.now() - request.user.date_joined) < timedelta(hours=site.cooloff_hours):
log.warning("User {0} tried to log in to {1} before cooloff period ended.".format(
request.user.username, site.name))
- return render_to_response('account/communityauth_cooloff.html', {
+ return render_pgweb(request, 'account', 'account/communityauth_cooloff.html', {
'site': site,
- }, NavContext(request, 'account'))
+ })
info = {
'u': request.user.username.encode('utf-8'),
-from django.shortcuts import render_to_response
-
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from models import ContributorType
def completelist(request):
contributortypes = list(ContributorType.objects.all())
- return render_to_response('contributors/list.html', {
+ return render_pgweb(request, 'community', 'contributors/list.html', {
'contributortypes': contributortypes,
- }, NavContext(request, 'community'))
+ })
-from django.shortcuts import render_to_response
+from django.shortcuts import render
from django.http import HttpResponse, Http404, HttpResponseRedirect
from django.http import HttpResponseNotModified
from django.template import TemplateDoesNotExist, loader
import urllib
from pgweb.util.decorators import cache, nocache
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb, get_nav_menu
from pgweb.util.helpers import simple_form, PgXmlHelper, HttpServerError
from pgweb.util.moderation import get_all_pending_moderations
from pgweb.util.misc import get_client_ip, varnish_purge
# models and forms needed for core objects
from models import Organisation
from forms import OrganisationForm, MergeOrgsForm
-from django.template.context import RequestContext
# Front page view
@cache(minutes=10)
curs.execute("SELECT * FROM (SELECT DISTINCT(core_organisation.name) FROM events_event INNER JOIN core_organisation ON org_id=core_organisation.id WHERE startdate <= (CURRENT_DATE + '6 Months'::interval) AND enddate >= CURRENT_DATE AND events_event.approved AND training AND org_id IS NOT NULL) x ORDER BY random() LIMIT 3")
trainingcompanies = [r[0] for r in curs.fetchall()]
- return render_to_response('index.html', {
+ return render(request, 'index.html', {
'title': 'The world\'s most advanced open source database',
'news': news,
'newstags': NewsTag.objects.all(),
'quote': quote,
'versions': versions,
'planet': planet,
- }, RequestContext(request))
+ })
# Community main page (contains surveys and potentially more)
def community(request):
except:
s = None
planet = ImportedRSSItem.objects.filter(feed__internalname="planet").order_by("-posttime")[:7]
- return render_to_response('core/community.html', {
+ return render_pgweb(request, 'community', 'core/community.html', {
'survey': s,
'planet': planet,
- }, NavContext(request, 'community'))
+ })
# List of supported versions
def versions(request):
- return render_to_response('support/versioning.html', {
+ return render_pgweb(request, 'support', 'support/versioning.html', {
'versions': Version.objects.filter(tree__gt=0).filter(testing=0),
- }, NavContext(request, 'support'))
+ })
re_staticfilenames = re.compile("^[0-9A-Z/_-]+$", re.IGNORECASE)
# Generic fallback view for static pages
navsect = url.split('/',2)[0]
except:
navsect = ''
- return HttpResponse(t.render(NavContext(request, navsect)))
+ return HttpResponse(t.render({'navmenu': get_nav_menu(navsect)}))
# Edit-forms for core objects
@login_required
@nocache
def csrf_failure(request, reason=''):
- resp = render_to_response('errors/csrf_failure.html', {
+ resp = render(request, 'errors/csrf_failure.html', {
'reason': reason,
})
resp.status_code = 403 # Forbidden
# Basic information about the connection
@cache(seconds=30)
def system_information(request):
- return render_to_response('core/system_information.html', {
+ return render(request,'core/system_information.html', {
'server': os.uname()[1],
'cache_server': request.META['REMOTE_ADDR'] or None,
'client_ip': get_client_ip(request),
@user_passes_test(lambda u: u.is_staff)
@user_passes_test(lambda u: u.groups.filter(name='web slaves').exists())
def admin_pending(request):
- return render_to_response('core/admin_pending.html', {
+ return render(request, 'core/admin_pending.html', {
'app_list': get_all_pending_moderations(),
- }, RequestContext(request))
+ })
# Purge objects from varnish, for the admin pages
@login_required
curs.execute("SELECT added, completed, consumer, mode, expr FROM varnishqueue.queue q LEFT JOIN varnishqueue.consumers c ON c.consumerid=q.consumerid ORDER BY added DESC")
latest = curs.fetchall()
- return render_to_response('core/admin_purge.html', {
+ return render(request, 'core/admin_purge.html', {
'latest_purges': latest,
- }, RequestContext(request))
+ })
@csrf_exempt
def api_varnish_purge(request):
else:
form = MergeOrgsForm()
- return render_to_response('core/admin_mergeorg.html', {
+ return render(request, 'core/admin_mergeorg.html', {
'form': form,
- }, RequestContext(request))
+ })
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import render, get_object_or_404
from django.http import HttpResponseRedirect, HttpResponsePermanentRedirect
from django.http import Http404
-from django.template.context import RequestContext
from pgweb.util.decorators import login_required
from django.db.models import Q
from django.conf import settings
from decimal import Decimal
import os
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import template_to_string
from pgweb.util.misc import send_template_mail
# Interactive documents are disabled, so redirect to static page
return HttpResponsePermanentRedirect("/docs/{0}/static/{1}.html".format(version, filename))
- return render_to_response('docs/docspage.html', {
+ return render(request, 'docs/docspage.html', {
'page': page,
'supported_versions': [v for v in versions if v.supported],
'devel_versions': [v for v in versions if not v.supported and v.testing],
'title': page.title,
'doc_index_filename': indexname,
'loaddate': loaddate,
- }, RequestContext(request))
+ })
def docsrootpage(request, version, typ):
return docpage(request, version, typ, 'index')
def root(request):
versions = Version.objects.filter(Q(supported=True) | Q(testing__gt=0,tree__gt=0)).order_by('-tree')
- return render_to_response('docs/index.html', {
+ return render_pgweb(request, 'docs', 'docs/index.html', {
'versions': versions,
- }, NavContext(request, 'docs'))
+ })
class _VersionPdfWrapper(Version):
"""
def manuals(request):
versions = Version.objects.filter(Q(supported=True) | Q(testing__gt=0,tree__gt=0)).order_by('-tree')
- return render_to_response('docs/manuals.html', {
+ return render_pgweb(request, 'docs', 'docs/manuals.html', {
'versions': [_VersionPdfWrapper(v) for v in versions],
- }, NavContext(request, 'docs'))
+ })
def manualarchive(request):
versions = Version.objects.filter(testing=0,supported=False,tree__gt=0).order_by('-tree')
- return render_to_response('docs/archive.html', {
+ return render_pgweb(request, 'docs', 'docs/archive.html', {
'versions': [_VersionPdfWrapper(v) for v in versions],
- }, NavContext(request, 'docs'))
+ })
@login_required
def commentform(request, itemid, version, filename):
replyto='%s, %s' % (form.cleaned_data['email'], settings.DOCSREPORT_EMAIL),
sendername='PG Doc comments form'
)
- return render_to_response('docs/docsbug_completed.html', {
- }, NavContext(request, 'docs'))
+ return render_pgweb(request, 'docs', 'docs/docsbug_completed.html', {})
else:
form = DocCommentForm(initial={
'name': '%s %s' % (request.user.first_name, request.user.last_name),
'email': request.user.email,
})
- return render_to_response('base/form.html', {
+ return render_pgweb(request, 'docs', 'base/form.html', {
'form': form,
'formitemtype': 'documentation correction',
'operation': 'Submit',
'form_intro': template_to_string('docs/docsbug.html', {
'user': request.user,
}),
- }, NavContext(request, 'docs'))
+ })
from django.core.urlresolvers import reverse
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, Http404, HttpResponseRedirect
from pgweb.util.decorators import login_required
from django.views.decorators.csrf import csrf_exempt
import json
from pgweb.util.decorators import nocache
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import simple_form, PgXmlHelper, HttpServerError
from pgweb.util.misc import get_client_ip, varnish_purge, version_sort
del node
- return render_to_response('downloads/ftpbrowser.html', {
+ return render_pgweb(request, 'download', 'downloads/ftpbrowser.html', {
'basepath': subpath.rstrip('/'),
'directories': directories,
'files': sorted(files),
'readme': file_readme,
'messagefile': file_message,
'maintainer': file_maintainer,
- }, NavContext(request, 'download'))
+ })
# Accept an upload of the ftpsite pickle. This is fairly resource consuming,
def yum_js(request):
with open(settings.YUM_JSON) as f:
jsonstr = f.read()
- return render_to_response('downloads/js/yum.js', {
+ return render(request, 'downloads/js/yum.js', {
'json': jsonstr,
'supported_versions': ','.join([str(v.numtree) for v in Version.objects.filter(supported=True)]),
}, content_type='application/json')
#######
def categorylist(request):
categories = Category.objects.all()
- return render_to_response('downloads/categorylist.html', {
+ return render_pgweb(request, 'download', 'downloads/categorylist.html', {
'categories': categories,
- }, NavContext(request, 'download'))
+ })
def productlist(request, catid, junk=None):
category = get_object_or_404(Category, pk=catid)
products = Product.objects.select_related('org','licencetype').filter(category=category, approved=True)
- return render_to_response('downloads/productlist.html', {
+ return render_pgweb(request, 'download', 'downloads/productlist.html', {
'category': category,
'products': products,
'productcount': len(products),
- }, NavContext(request, 'download'))
+ })
@login_required
def productform(request, itemid):
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
from django.http import Http404
from pgweb.util.decorators import login_required
from datetime import date
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import simple_form
from models import Event
community_events = Event.objects.select_related('country').filter(approved=True, badged=True).filter(training=False, enddate__gt=date.today()).order_by('enddate', 'startdate',)
other_events = Event.objects.select_related('country').filter(approved=True, badged=False).filter(training=False, enddate__gt=date.today()).order_by('enddate', 'startdate',)
training = Event.objects.select_related('country').filter(approved=True).filter(training=True, enddate__gt=date.today()).order_by('enddate', 'startdate',)
- return render_to_response('events/archive.html', {
+ return render_pgweb(request, 'about', 'events/archive.html', {
'title': 'Upcoming events',
'eventblocks': (
{ 'name': 'Community Events', 'events': community_events, 'link': '',},
{ 'name': 'Other Events', 'events': other_events, 'link': '',},
{ 'name': 'Training', 'events': training, 'link': 'training/',},
),
- }, NavContext(request, 'about'))
+ })
def _eventarchive(request, training, title):
# Hardcode to the latest 100 events. Do we need paging too?
events = Event.objects.select_related('country').filter(approved=True).filter(training=training, enddate__lte=date.today()).order_by('-enddate', '-startdate',)[:100]
- return render_to_response('events/archive.html', {
+ return render_pgweb(request, 'about', 'events/archive.html', {
'title': '%s Archive' % title,
'archive': True,
'eventblocks': (
{'name': title, 'events': events, },
),
- }, NavContext(request, 'about'))
+ })
def archive(request):
return _eventarchive(request, False, 'Event')
event = get_object_or_404(Event, pk=itemid)
if not event.approved:
raise Http404
- return render_to_response('events/item.html', {
+ return render_pgweb(request, 'about', 'events/item.html', {
'obj': event,
- }, NavContext(request, 'about'))
+ })
@login_required
def form(request, itemid):
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.core.models import Version
from models import Feature
groups.append(currentgroup)
eol_versions = [v.tree for v in Version.objects.filter(supported=False, testing=False)]
- return render_to_response('featurematrix/featurematrix.html', {
+ return render_pgweb(request, 'about', 'featurematrix/featurematrix.html', {
'groups': groups,
'eol_versions': eol_versions,
- }, NavContext(request, 'about'))
+ })
def detail(request, featureid):
feature = get_object_or_404(Feature, pk=featureid)
- return render_to_response('featurematrix/featuredetail.html', {
+ return render_pgweb(request, 'about', 'featurematrix/featuredetail.html', {
'feature': feature,
- }, NavContext(request, 'about'))
+ })
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
from django.http import HttpResponse, HttpResponseForbidden
from django.views.decorators.csrf import csrf_exempt
from django.conf import settings
-from django.shortcuts import render_to_response
from pgweb.util.decorators import login_required
from django.http import HttpResponse
from django.db import connection
import os
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import template_to_string
from pgweb.util.misc import send_template_mail
sendername="PG Bug reporting form",
)
- return render_to_response('misc/bug_completed.html', {
+ return render_pgweb(request, 'support', 'misc/bug_completed.html', {
'bugid': bugid,
- }, NavContext(request, 'support'))
+ })
else:
form = SubmitBugForm(initial={
'name': '%s %s' % (request.user.first_name, request.user.last_name),
versions = Version.objects.filter(supported=True)
- return render_to_response('base/form.html', {
+ return render_pgweb(request, 'support', 'base/form.html', {
'form': form,
'formitemtype': 'bug report',
'operation': 'Submit',
'form_intro': template_to_string('misc/bug_header.html', {
'supportedversions': versions,
}),
- }, NavContext(request, 'support'))
+ })
# A crash testing URL. If the file /tmp/crashtest exists, raise a http 500
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
from django.http import HttpResponse, Http404
from pgweb.util.decorators import login_required
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import simple_form
from models import NewsArticle, NewsTag
else:
tag = None
news = NewsArticle.objects.filter(approved=True)
- return render_to_response('news/newsarchive.html', {
+ return render_pgweb(request, 'about', 'news/newsarchive.html', {
'news': news,
'tag': tag,
'newstags': NewsTag.objects.all(),
- }, NavContext(request, 'about'))
+ })
def item(request, itemid, throwaway=None):
news = get_object_or_404(NewsArticle, pk=itemid)
if not news.approved:
raise Http404
- return render_to_response('news/item.html', {
+ return render_pgweb(request, 'about', 'news/item.html', {
'obj': news,
'newstags': NewsTag.objects.all(),
- }, NavContext(request, 'about'))
+ })
def taglist_json(request):
return HttpResponse(json.dumps({
-from django.shortcuts import render_to_response
from django.http import Http404
from pgweb.util.decorators import login_required
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.helpers import simple_form
from models import ProfessionalService
title = servtype=='support' and 'Professional Services' or 'Hosting Providers'
what = servtype=='support' and 'support' or 'hosting'
support = servtype=='support'
- return render_to_response('profserv/root.html', {
+ return render_pgweb(request, 'support', 'profserv/root.html', {
'title': title,
'support': support,
'regions': regions,
'what': what,
- }, NavContext(request, 'support'))
+ })
def region(request, servtype, regionname):
# Field names are cleaned up earlier, so it's safe against injections.
services = ProfessionalService.objects.select_related('org').filter(approved=True).extra(where=["region_%s AND provides_%s" % (regionname, what),])
- return render_to_response('profserv/list.html', {
+ return render_pgweb(request, 'support', 'profserv/list.html', {
'title': title,
'support': support,
'what': what,
'whatname': whatname,
'regionname': regname,
'services': services,
- }, NavContext(request, 'support'))
+ })
# Forms to edit
-from django.shortcuts import render_to_response
-
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from models import PUG
'country': pug.country.name,
'pugs': [pug]
})
- return render_to_response('pugs/index.html', {
+ return render_pgweb(request, 'community', 'pugs/index.html', {
'pug_list': pug_list,
- }, NavContext(request, 'community'))
+ })
-from django.shortcuts import render_to_response
-
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from models import Quote
def allquotes(request):
quotes = Quote.objects.filter(approved=True)
- return render_to_response('quotes/quotelist.html', {
+ return render_pgweb(request, 'about', 'quotes/quotelist.html', {
'quotes': quotes,
- }, NavContext(request, 'about'))
+ })
-from django.shortcuts import render_to_response
-from django.template.context import RequestContext
+from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.views.decorators.csrf import csrf_exempt
from django.conf import settings
# Check that we actually have something to search for
if not request.GET.has_key('q') or request.GET['q'] == '':
if searchlists:
- return render_to_response('search/listsearch.html', {
+ return render(request, 'search/listsearch.html', {
'search_error': "No search term specified.",
'sortoptions': sortoptions,
'lists': MailingList.objects.all().order_by("group__sortkey"),
'listid': listid,
'dates': dateoptions,
'dateval': dateval,
- }, RequestContext(request))
+ })
else:
- return render_to_response('search/sitesearch.html', {
+ return render(request, 'search/sitesearch.html', {
'search_error': "No search term specified.",
- }, RequestContext(request))
+ })
query = request.GET['q'].strip()
# Anti-stefan prevention
if len(query) > 1000:
- return render_to_response('search/sitesearch.html', {
+ return render(request, 'search/sitesearch.html', {
'search_error': "Search term too long.",
- }, RequestContext(request))
+ })
# Is the request being paged?
if request.GET.has_key('p'):
try:
r = c.getresponse()
except (socket.timeout, ssl.SSLError):
- return render_to_response('search/listsearch.html', {
+ return render(request, 'search/listsearch.html', {
'search_error': 'Timeout when talking to search server. Please try your search again later, or with a more restrictive search terms.',
- }, RequestContext(request))
+ })
if r.status != 200:
memc = None
- return render_to_response('search/listsearch.html', {
+ return render(request, 'search/listsearch.html', {
'search_error': 'Error talking to search server: %s' % r.reason,
- }, RequestContext(request))
+ })
hits = json.loads(r.read())
if has_memcached and memc:
# Store them in memcached too! But only for 10 minutes...
listsort
)
- return render_to_response('search/listsearch.html', {
+ return render(request, 'search/listsearch.html', {
'hitcount': totalhits,
'firsthit': firsthit,
'lasthit': min(totalhits, firsthit+hitsperpage-1),
'listid': listid,
'dates': dateoptions,
'dateval': dateval,
- }, RequestContext(request))
+ })
else:
# Website search is still done by making a regular pgsql connection
conn = psycopg2.connect(settings.SEARCH_DSN)
curs = conn.cursor()
except:
- return render_to_response('search/sitesearch.html', {
+ return render(request, 'search/sitesearch.html', {
'search_error': 'Could not connect to search database.'
- }, RequestContext(request))
+ })
# This is kind of a hack, but... Some URLs are flagged as internal
# and should as such only be included in searches that explicitly
'internal': include_internal,
})
except psycopg2.ProgrammingError:
- return render_to_response('search/sitesearch.html', {
+ return render(request, 'search/sitesearch.html', {
'search_error': 'Error executing search query.'
- }, RequestContext(request))
+ })
hits = curs.fetchall()
conn.close()
suburl and urllib.quote_plus(suburl) or '',
)
- return render_to_response('search/sitesearch.html', {
+ return render(request, 'search/sitesearch.html', {
'suburl': suburl,
'allsites': allsites,
'hitcount': totalhits,
'url': "%s%s" % (h[1], h[2]),
'abstract': h[4].replace("[[[[[[", "<b>").replace("]]]]]]","</b>"),
'rank': h[5]} for h in hits[:-1]],
- }, RequestContext(request))
+ })
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.core.models import Version
from models import SecurityPatch
def _list_patches(request, filt):
patches = GetPatchesList(filt)
- return render_to_response('security/security.html', {
+ return render_pgweb(request, 'support', 'security/security.html', {
'patches': patches,
'supported': Version.objects.filter(supported=True),
'unsupported': Version.objects.filter(supported=False, tree__gt=0).extra(
where=["EXISTS (SELECT 1 FROM security_securitypatchversion pv WHERE pv.version_id=core_version.id)"],
),
- }, NavContext(request, 'support'))
+ })
def index(request):
# Show all supported versions
-from django.shortcuts import render_to_response
-
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.decorators import cache
from models import Sponsor, Server
@cache(minutes=30)
def sponsors(request):
sponsors = Sponsor.objects.select_related().filter(sponsortype__sortkey__gt=0).order_by('sponsortype__sortkey' ,'?')
- return render_to_response('sponsors/sponsors.html', {
+ return render_pgweb(request, 'about', 'sponsors/sponsors.html', {
'sponsors': sponsors,
- }, NavContext(request, 'about'))
+ })
def servers(request):
servers = Server.objects.select_related().all()
- return render_to_response('sponsors/servers.html', {
+ return render_pgweb(request, 'about', 'sponsors/servers.html', {
'servers': servers,
- }, NavContext(request, 'about'))
+ })
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import get_object_or_404
from django.http import HttpResponseRedirect
from django.db import connection, transaction
from django.template.defaultfilters import slugify
from django.views.decorators.csrf import csrf_exempt
-from pgweb.util.contexts import NavContext
+from pgweb.util.contexts import render_pgweb
from pgweb.util.misc import get_client_ip, varnish_purge
from pgweb.util.helpers import HttpServerError
survey = get_object_or_404(Survey, pk=surveyid)
surveylist = Survey.objects.all().order_by('-posted')
- return render_to_response('survey/results.html', {
+ return render_pgweb(request, 'community', 'survey/results.html', {
'survey': survey,
'surveylist': surveylist,
- }, NavContext(request, 'community'))
+ })
# Served over insecure HTTP, the Varnish proxy strips cookies
@csrf_exempt
-from django.template import RequestContext
from django.utils.functional import SimpleLazyObject
+from django.shortcuts import render
from django.conf import settings
# This is the whole site navigation structure. Stick in a smarter file?
}
-class NavContext(RequestContext):
- def __init__(self, request, section):
- RequestContext.__init__(self, request)
- if sitenav.has_key(section):
- navsection = sitenav[section]
- else:
- navsection = {}
- self.update({'navmenu': navsection})
+def get_nav_menu(section):
+ if sitenav.has_key(section):
+ return sitenav[section]
+ else:
+ return {}
+def render_pgweb(request, section, template, context):
+ context['navmenu'] = get_nav_menu(section)
+ return render(request, template, context)
def _get_gitrev():
# Return the current git revision, that is used for
-from django.shortcuts import render_to_response, get_object_or_404
-from pgweb.util.contexts import NavContext
+from django.shortcuts import render, get_object_or_404
+from pgweb.util.contexts import render_pgweb
from django.http import HttpResponseRedirect, Http404
from django.template import Context
from django.template.loader import get_template
else:
described_checkboxes = None
- return render_to_response(formtemplate, {
+ return render_pgweb(request, navsection, formtemplate, {
'form': form,
'formitemtype': instance._meta.verbose_name,
'markdownfields': markdownfields,
'jquery': hasattr(form, 'jquery') and form.jquery or None,
'savebutton': (itemid == "new") and "New" or "Save",
'operation': (itemid == "new") and "New" or "Edit",
- }, NavContext(request, navsection))
+ })
def template_to_string(templatename, attrs = {}):
return get_template(templatename).render(Context(attrs))
def HttpServerError(msg):
- r = render_to_response('errors/500.html', {
+ r = render(request, 'errors/500.html', {
'message': msg,
})
r.status_code = 500
projects / pgweb.git / commitdiff