def scoreboard(request, site_id=None, category=None):
sortMethods = {
"score": "score",
"name": "name",
"wins": playersByWins,
"losses": playersByLosses,
"winPct": playersByWinPct,
"modded": playersByModerated,
"default": "score",
}
nextDir = {"up": "down", "down": "up"}
if ("direction" in request.GET) and (request.GET["direction"] in nextDir):
direction = nextDir[request.GET["direction"]]
else:
direction = "up"
query = Player.objects
if (site_id is not None) and (site_id != ""):
site = get_object_or_404(Site, pk=site_id)
funcArgs = {"site": site}
query = query.filter(played__gt=0, site=site)
else:
query = query.filter(played__gt=0)
funcArgs = {"site": None}
if (category is not None) and (category != ""):
category = get_object_or_404(Category, pk=category)
funcArgs["type"] = category
players = sortTable(
request.GET, sortMethods, [x for x in query if x.playedCalc(category) > 0], category=category
)
else:
players = sortTable(request.GET, sortMethods, query)
# players = [(player,player.score()) for player in players if player.played()>0]
# players.sort(cmp=(lambda (x,xs),(y,ys): cmp(ys,xs)))
# players,scores = zip(*players)
paginator = Paginator(players, 25)
page = getPage(request, paginator)
if "method" in request.GET:
meth = request.GET["method"]
else:
meth = sortMethods["score"]
if request.is_ajax():
args = {
"players": page.object_list,
"page": page,
"direction": direction,
"pageArgs": {"method": meth, "direction": direction},
}
args.update(funcArgs)
return render_to_response("scoreBoardPresenter.html", args, context_instance=RequestContext(request))
args = {
"players": page.object_list,
"categories": Category.objects.all(),
"page": page,
"direction": direction,
"pageArgs": {"method": meth, "direction": direction},
}
args.update(funcArgs)
return render_to_response("scoreboard.html", args, context_instance=RequestContext(request))
def wrapper(request, *args, **kwargs):
try:
context = view_func(request, *args, **kwargs)
if not context:
raise Exception('No context generated')
# Skip render on redirect
if isinstance(context, HttpResponseRedirect):
return context
# Add some settings to context
context['DEBUG'] = DEBUG
context['IS_AJAX'] = request.is_ajax()
#context['GOOGLE_ANALYTICS'] = GOOGLE_ANALYTICS
# Ajax render using json
if request.is_ajax() and json_template:
# Render the template to html
html = render_to_string(json_template, context)
json_data = {
'status' : 'ok',
'html' : html,
}
resp = HttpResponse(mimetype='application/json')
resp.write(simplejson.dumps(json_data))
# Html render
elif html_template:
resp = render_to_response(
html_template,
context,
context_instance=RequestContext(request),
)
else:
raise Exception('No template found')
except Exception, e:
if DEBUG:
raise
if request.is_ajax():
json_data = {'status' : 'error', 'message' : str(e)}
resp = HttpResponse(mimetype='application/json')
resp.write(simplejson.dumps(json_data))
else:
resp = render_to_response(
'error.html',
{'error' : str(e),},
)
def badge_delete(request, pk):
badge = get_object_or_404(Badge, pk=int(pk))
if request.user.pk != badge.user.pk:
return render_to_response(
"badge_delete.html",
{"can_delete": False, "message": "You cannot unlink this account"},
context_instance=RequestContext(request),
)
if request.method == "POST":
badge.delete()
return HttpResponseRedirect(reverse("account_profile"))
return render_to_response(
"badge_delete.html", {"can_delete": True, "pk": pk}, context_instance=RequestContext(request)
)
def transaction_success(request, token, result=None):
# Check the transaction was actually successful, since there's nothing
# to stop DPS or whoever requesting the "success" url for a failed
# transaction
if result['Success'] != '1':
return HttpResponseForbidden('Transaction was unsuccessful')
transaction = get_object_or_404(Transaction,
status__in=[Transaction.PROCESSING,
Transaction.SUCCESSFUL],
secret=token)
transaction.result = pformat(result, width=1)
transaction.save()
status_updated = transaction.set_status(Transaction.SUCCESSFUL)
# if we're recurring, we need to save the billing token now.
content_object = transaction.content_object
if content_object.is_recurring():
content_object.set_billing_token(result["DpsBillingId"] or None)
# callback, if it exists. It may optionally return a url for redirection
success_url = getattr(content_object,
"transaction_succeeded",
lambda *args: None)(transaction, True, status_updated)
if success_url:
# assumed to be a valid url
return HttpResponseRedirect(success_url)
else:
return render_to_response("dps/transaction_success.html", RequestContext(request, {
"transaction": transaction}))
def password_reset_from_key(request, uidb36, key, **kwargs):
form_class = kwargs.get("form_class", ResetPasswordKeyForm)
template_name = kwargs.get("template_name", "account/password_reset_from_key.html")
token_generator = kwargs.get("token_generator", default_token_generator)
# pull out user
try:
uid_int = base36_to_int(uidb36)
except ValueError:
raise Http404
user = get_object_or_404(User, id=uid_int)
if token_generator.check_token(user, key):
if request.method == "POST":
password_reset_key_form = form_class(request.POST, user=user, temp_key=key)
if password_reset_key_form.is_valid():
password_reset_key_form.save()
get_adapter().add_message(request,
messages.SUCCESS,
'account/messages/password_changed.txt')
signals.password_reset.send(sender=user.__class__,
request=request, user=user)
password_reset_key_form = None
else:
password_reset_key_form = form_class()
ctx = { "form": password_reset_key_form, }
else:
ctx = { "token_fail": True, }
return render_to_response(template_name, RequestContext(request, ctx))
def email(request, **kwargs):
form_class = kwargs.pop("form_class", AddEmailForm)
template_name = kwargs.pop("template_name", "account/email.html")
sync_user_email_addresses(request.user)
if request.method == "POST" and request.user.is_authenticated():
if "action_add" in request.POST:
add_email_form = form_class(request.user, request.POST)
if add_email_form.is_valid():
email_address = add_email_form.save(request)
get_adapter().add_message(request,
messages.INFO,
'account/messages/email_confirmation_sent.txt',
{ 'email': add_email_form.cleaned_data["email"] })
signals.email_added.send(sender=request.user.__class__,
request=request, user=request.user,
email_address=email_address)
return HttpResponseRedirect(reverse('account_email'))
else:
add_email_form = form_class()
if request.POST.get("email"):
email = request.POST["email"]
try:
email_address = EmailAddress.objects.get(
user=request.user,
email=email)
return _no_add_email_action(request, email_address)
except EmailAddress.DoesNotExist:
pass
else:
add_email_form = form_class()
ctx = { "add_email_form": add_email_form }
return render_to_response(template_name, RequestContext(request, ctx))
def transaction_failure(request, token, result=None):
# Check the transaction actually failed, since there's nothing
# to stop DPS or whoever requesting the "failure" url for a successful
# transaction
if result['Success'] != '0':
return HttpResponseForbidden('Transaction was successful')
transaction = get_object_or_404(Transaction,
status__in=[Transaction.PROCESSING,
Transaction.FAILED],
secret=token)
transaction.result = pformat(result, width=1)
transaction.save()
status_updated = transaction.set_status(Transaction.FAILED)
content_object = transaction.content_object
# callback, if it exists. It may optionally return a url for redirection
failure_url = getattr(content_object,
"transaction_failed",
lambda *args: None)(transaction, True, status_updated)
if failure_url:
# assumed to be a valid url
return HttpResponseRedirect(failure_url)
else:
return render_to_response("dps/transaction_failure.html", RequestContext(request, {
"transaction": transaction}))
def index(request):
site_list = Site.objects.all()[:5]
stats = [site.sitestats for site in Site.objects.all()]
newest = max((stat.newest_game.end_date, stat.newest_game) for stat in stats)[
1
] # Game.objects.order_by('-end_date')[0]
largest = max((stat.largest_game.num_players(), stat.largest_game) for stat in stats)[1]
smallest = min((stat.smallest_game.num_players(), stat.smallest_game) for stat in stats)[1]
totalPlayed = Game.objects.count()
numPlayers = Player.objects.count()
win_list = [
p for w, p in sorted(((p.wins(), p) for stat in stats for p in stat.winningest.all()), reverse=True)[0:5]
]
loss_list = [
p for l, p in sorted(((p.losses(), p) for stat in stats for p in stat.losingest.all()), reverse=True)[0:5]
]
mostMod = max(((stat.most_modded.modded(), stat.most_modded) for stat in stats))[1]
mostPlayed = max((stat.most_played.played, stat.most_played) for stat in stats)[1]
stats = {
"win_list": win_list,
"loss_list": loss_list,
"sidebar": [
("Newest Game", newest),
("Largest Game", largest),
("Smallest Game", smallest),
("Games Played", totalPlayed),
("Number of Players", numPlayers),
("Most Prolific Mod", mostMod),
("Most Games Played", mostPlayed),
],
}
return render_to_response(
"index.html", {"site": None, "stats": stats, "site_list": site_list}, context_instance=RequestContext(request)
)
def extra(request, provider):
"""
Handle registration of new user with extra data for profile
"""
identity = request.session.get('identity', None)
if not identity:
raise Http404
if request.method == "POST":
form = str_to_class(netauth_settings.EXTRA_FORM)(request.POST)
if form.is_valid():
user = form.save(request, identity, provider)
del request.session['identity']
if not netauth_settings.ACTIVATION_REQUIRED:
user = auth.authenticate(identity=identity, provider=provider)
if user:
auth.login(request, user)
return redirect(request.session.pop('next_url', netauth_settings.LOGIN_REDIRECT_URL))
else:
messages.warning(request, lang.ACTIVATION_REQUIRED_TEXT)
return redirect(netauth_settings.ACTIVATION_REDIRECT_URL)
else:
initial = request.session['extra']
form = str_to_class(netauth_settings.EXTRA_FORM)(initial=initial)
return render_to_response('netauth/extra.html', {'form': form }, context_instance=RequestContext(request))
def welcome(request):
c = get_context(request, css_class='body-welcome', title=_('Inicio'))
c['formatter'] = add_thousands_separator
# Retrieve setting for number of examples to display in homepage
c['number_of_featured_programmes'] = 3
if hasattr(settings, 'NUMBER_OF_FEATURED_PROGRAMMES'):
c['number_of_featured_programmes'] = settings.NUMBER_OF_FEATURED_PROGRAMMES
# Retrieve front page examples
populate_latest_budget(c)
c['featured_programmes'] = list(FunctionalCategory.objects
.filter(budget=c['latest_budget'])
.filter(programme__in=settings.FEATURED_PROGRAMMES)
.filter(subprogramme=None))
# Decide whether we're going to show budget or execution figures
use_actual = (BudgetItem.objects
.filter(budget=c['latest_budget'])
.filter(budget__status='') # Don't use partially executed budgets
.filter(actual=True).count() > 0)
# Calculate subtotals for the selected programmes
c['breakdown'] = BudgetBreakdown(['programme'])
items = BudgetItem.objects \
.filter(budget=c['latest_budget']) \
.filter(functional_category__programme__in=settings.FEATURED_PROGRAMMES) \
.filter(actual=use_actual)
for item in items:
c['breakdown'].add_item(c['latest_budget'].year, item)
return render_to_response('welcome/index.html', c)
def details(request, seqname):
try:
transcript = Transcript.objects.get(seqname=seqname)
except ObjectDoesNotExist:
raise Http404
if transcript.homology_set.all().exists():
reference = Refseq.objects.get(accession=transcript.homology_set.all()[0].hit_name_id)
alignment_protein = alignment.pairwise_protein(transcript.seqname,
transcript.seq,
transcript.homology_set.all()[0].query_frame,
reference.accession,
reference.seq,
transcript.homology_set.all()[0].hit_frame)
alignment_protein_html = formatter.clustal_to_html(alignment_protein, 'a')
else:
alignment_protein_html = ''
return render_to_response('transcriptome/details.jinja2',
{'transcript': transcript,
'alignment_protein_html': alignment_protein_html},
context_instance=RequestContext(request))
def show_form(request, query_set=None, javascript=False, model=None, statistics_variable=None):
if request.method == "POST" and request.is_ajax():
query = request.POST
user = request.user
rdict = build_graph(query, user)
wiki_code = reverse_translate_query(query)
rdict["wiki_code"] = wiki_code
rdict["query_link"] = b64encode(smart_str(query.urlencode()))
json = simplejson.dumps(rdict, ensure_ascii=False)
return HttpResponse(json, mimetype="application/javascript")
else:
username = ""
if request.user.is_anonymous() == True:
username = "******"
else:
username = request.user.get_full_name()
if username == "":
username = request.user.username
form = DbForm()
response_dic = {"form": form, "request": request, "username": username}
if statistics_variable:
response_dic["statistics_variable"] = statistics_variable
response_template = "/simple_graph_form.html"
else:
response_template = "/graph_form.html"
return render_to_response(response_template, response_dic, context_instance=RequestContext(request))
def welcome(request):
c = get_context(request, css_class='body-welcome', title=_('Inicio'))
c['formatter'] = add_thousands_separator
# Retrieve front page examples
populate_latest_budget(c)
c['featured_programmes'] = list(FunctionalCategory.objects
.filter(budget=c['latest_budget'])
.filter(policy__in=settings.FEATURED_PROGRAMMES))
# Decide whether we're going to show budget or execution figures
use_actual = False
for programme in c['featured_programmes']:
if (BudgetItem.objects
.filter(functional_category=programme)
.filter(budget__status='') # Don't use partially executed budgets
.filter(actual=True).count()) > 0:
use_actual = True
break
# Calculate subtotals for the selected programmes
c['breakdown'] = BudgetBreakdown(['policy'])
for programme in c['featured_programmes']:
#list budget items for the selected programme
for item in programme.budgetitem_set.filter(actual=use_actual):
c['breakdown'].add_item(c['latest_budget'].year, item)
return render_to_response('welcome/index.html', c)
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME,
username_label=None):
"Displays the login form and handles the login action."
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
# Light security check -- make sure redirect_to isn't garbage.
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
from django.contrib.auth import login
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = AuthenticationForm(request)
request.session.set_test_cookie()
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
if username_label:
form.fields['username'].label = username_label
return render_to_response(template_name, {
'form': form,
redirect_field_name: redirect_to,
'site': current_site,
'site_name': current_site.name,
}, context_instance=RequestContext(request))
def single_entry(request, entry_id, extra_context=None,
template='single_entry.html'):
if not extra_context:
extra_context = {}
entry = get_object_or_404(Entry, id=entry_id)
user = request.user
if request.path.endswith('intermed/'):
user_groups = [t[0] for t in user.groups.values_list('name')]
if not (user.preplock and entry.preplock) \
and (not entry.authors.exists() or user.is_superuser
or 'editors' in user_groups or 'admins' in user_groups
or user in entry.authors.all()):
pass
else:
return redirect(entry.get_absolute_url())
context = {
'entry': entry,
'title': u'Статья «%s»' % entry.civil_equivalent,
'show_additional_info': 'ai' in request.COOKIES,
'user': user,
}
context.update(extra_context)
return render_to_response(template, context, RequestContext(request))
def antconc2ucs8_converter(request):
random.seed()
examples = (
u"Дрꙋ'гъ дрꙋ'га тѧготы^ носи'те, и та'кѡ испо'лните зако'нъ хрСто'въ.",
u"Ѿ дне'й же іѡа'нна крСти'телѧ досе'лѣ, црСтвіе нбСное нꙋ'дитсѧ, "
u"и нꙋ'ждницы восхища'ютъ є`",
u"Пре'жде же всѣ'хъ дрꙋ'гъ ко дрꙋ'гꙋ любо'вь прилѣ'жнꙋ имѣ'йте: "
u"зане` любо'вь покрыва'етъ мно'жество грѣхѡ'въ. "
u"Страннолю'бцы дрꙋ'гъ ко дрꙋ'гꙋ, безЪ ропта'ній.",
u"Наказꙋ'ѧ наказа' мѧ гдСь, сме'рти же не предаде' мѧ",
u"Вни'дите ѹ'зкими враты`, ꙗ'кѡ простра'ннаѧ врата`, и широ'кій "
u"пꙋ'ть вводѧ'й въ па'гꙋбꙋ, и мно'зи сꙋ'ть входѧ'щіи и'мъ. Что` "
u"ѹ'зкаѧ врата`, и тѣ'сный пꙋ'ть вводѧ'й въ живо'тъ, и ма'лѡ и'хъ "
u"є'сть, и`же ѡбрѣта'ютъ єго`",
u"Бꙋ'дите ѹ'бѡ вы` соверше'ни, ꙗ'коже ѻц~ъ ва'шъ нбСный "
u"соверше'нъ є'сть.",
u"Возведо'хъ ѻ'чи мои` въ го'ры, ѿню'дꙋже пріи'детъ по'мощь моѧ`",
)
context = { 'convertee': random.choice(examples) }
return render_to_response('converter.html', context,
RequestContext(request))
def wrapper(request, *args, **kwargs):
output = function(request, *args, **kwargs)
if not isinstance(output, dict):
return output
tmpl = output.pop('TEMPLATE', template)
return render_to_response(tmpl, output, \
context_instance=RequestContext(request), mimetype=mimetype)
def budgets(request):
# Get request context
c = get_context(request, css_class='body-summary', title='')
# Retrieve the entity to display
main_entity = get_main_entity(c)
# Income/expense breakdown
#c['functional_breakdown'] = BudgetBreakdown(['policy', 'programme'])
c['functional_breakdown'] = BudgetBreakdown(['area'])
# c['economic_breakdown'] = BudgetBreakdown(['article', 'heading'])
c['economic_breakdown'] = BudgetBreakdown(['article'])
# c['chapter_breakdown'] = BudgetBreakdown(['chapter']) # Used for indicators
c['include_financial_chapters'] = hasattr(settings, 'INCLUDE_FINANCIAL_CHAPTERS_IN_BREAKDOWNS') and settings.INCLUDE_FINANCIAL_CHAPTERS_IN_BREAKDOWNS
for item in BudgetItem.objects.each_denormalized("e.id = %s", [main_entity.id]):
column_name = year_column_name(item)
# c['chapter_breakdown'].add_item(column_name, item)
if c['include_financial_chapters'] or not item.is_financial():
c['functional_breakdown'].add_item(column_name, item)
c['economic_breakdown'].add_item(column_name, item)
# Additional data needed by the view
populate_stats(c)
populate_descriptions(c)
populate_budget_statuses(c, main_entity)
populate_years(c, 'functional_breakdown')
c['income_nodes'] = json.dumps(settings.OVERVIEW_INCOME_NODES)
c['expense_nodes'] = json.dumps(settings.OVERVIEW_EXPENSE_NODES)
return render_to_response('budgets/index.html', c)
def upload(request):
if request.method == 'POST':
form = forms.UploadFileForm(request.POST, request.FILES)
if form.is_valid():
score_filepath = {'ucsc15': settings.CSMAP_SCOREDATA_UCSC15,
'vista12': settings.CSMAP_SCOREDATA_VISTA12,
'vista6': settings.CSMAP_SCOREDATA_VISTA6}
if request.POST.get('partial') == 'on':
partial = True
else:
partial = False
csmap_result, error_line = csmap.parse(request.FILES['upload_file'],
score_filepath.get(request.POST.get('score_data')),
partial)
if csmap_result is None:
# Format Error
upload_form = forms.UploadFileForm()
return render_to_response('csmapper/index.jinja2',
{'error_line': error_line,
'upload_form': upload_form},
context_instance=RequestContext(request))
else:
response = HttpResponse(csmap_result, content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=%s' % request.POST.get('score_data') + '_score.txt'
return response
else:
return HttpResponseRedirect('/csmapper/')
else:
return HttpResponseRedirect('/csmapper/')
def entities_compare(request, c, entity_left, entity_right):
c['entity_left'] = entity_left
c['entity_right'] = entity_right
# Get the budget breakdowns
# XXX: No good functional data at this level so far
# c['functional_breakdown_left'] = BudgetBreakdown(['policy'])
c['economic_breakdown_left'] = BudgetBreakdown(['chapter', 'article'])
get_budget_breakdown( "e.name = %s and ec.chapter <> 'X'", [ entity_left.name ],
[
c['economic_breakdown_left']
])
c['economic_breakdown_right'] = BudgetBreakdown(['chapter', 'article'])
get_budget_breakdown( "e.name = %s and ec.chapter <> 'X'", [ entity_right.name ],
[
c['economic_breakdown_right']
])
# Additional data needed by the view
populate_level(c, entity_left.level)
populate_entity_stats(c, entity_left, 'stats_left')
populate_entity_stats(c, entity_right, 'stats_right')
populate_entity_descriptions(c, entity_left)
populate_area_descriptions(c, ['income', 'expense'])
populate_comparison_years(c, 'economic_breakdown_left', 'economic_breakdown_right')
populate_entities(c, entity_left.level)
return render_to_response('entities/compare.html', c)
def password_reset_confirm(request, uidb36=None, token=None, template_name='registration/password_reset_confirm.html',
token_generator=default_token_generator, set_password_form=SetPasswordForm,
post_reset_redirect=None):
"""
View that checks the hash in a password reset link and presents a
form for entering a new password.
"""
assert uidb36 is not None and token is not None # checked by URLconf
if post_reset_redirect is None:
post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')
try:
uid_int = base36_to_int(uidb36)
except ValueError:
raise Http404
user = get_object_or_404(User, id=uid_int)
context_instance = RequestContext(request)
if token_generator.check_token(user, token):
context_instance['validlink'] = True
if request.method == 'POST':
form = set_password_form(user, request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(post_reset_redirect)
else:
form = set_password_form(None)
else:
context_instance['validlink'] = False
form = None
context_instance['form'] = form
return render_to_response(template_name,{
'request': request,
}, context_instance=context_instance)
def password_reset(request, is_admin_site=False, template_name='registration/password_reset_form.html',
email_template_name='registration/password_reset_email.html',
password_reset_form=PasswordResetForm, token_generator=default_token_generator,
post_reset_redirect=None):
if post_reset_redirect is None:
post_reset_redirect = reverse('django.contrib.auth.views.password_reset_done')
if request.method == "POST":
form = password_reset_form(request.POST)
if form.is_valid():
opts = {}
opts['use_https'] = request.is_secure()
opts['token_generator'] = token_generator
if is_admin_site:
opts['domain_override'] = request.META['HTTP_HOST']
else:
opts['email_template_name'] = email_template_name
if not Site._meta.installed:
opts['domain_override'] = RequestSite(request).domain
form.save(**opts)
return HttpResponseRedirect(post_reset_redirect)
else:
form = password_reset_form()
return render_to_response(template_name, {
'form': form,
'request': request,
}, context_instance=RequestContext(request))
def events(request, mode):
ctx = {
'events': list(Event.objects.get_events(mode)),
}
ctx['bets'] = create_bets_dict(request.user, ctx['events'])
return render_to_response('events/events.html', ctx, RequestContext(request))
def post(request):
data = request.POST.copy()
# inject the user and IP
data['user'] = request.user.id
form = forms.CommentForm(data, ip=request.META['REMOTE_ADDR'])
if form.is_valid():
comment = form.save()
if comment:
if request.is_ajax():
context = RequestContext(request, {'c': comment})
return render_to_response('tcc/comment.html', context)
next = form.cleaned_data['next']
if not next:
next = comment.get_absolute_url()
return HttpResponseRedirect(next)
if request.is_ajax():
return HttpResponseBadRequest(
form_utils.error_form_serialization(form.errors),
mimetype='application/json',
)
else:
content_type_id = data.get('content_type_id',
data.get('content_type'))
return content_type_redirect(
request,
content_type_id=content_type_id,
object_pk=data.get('object_pk'),
)
def login(request):
if 'openid' in request.GET or request.method == 'POST':
form = LoginForm(request.REQUEST)
if form.is_valid():
client = _openid_consumer(request)
try:
auth_request = client.begin(form.cleaned_data['openid'])
if QUERY_EMAIL:
sreg = SRegRequest()
sreg.requestField(field_name=SRegField.EMAIL, required=True)
auth_request.addExtension(sreg)
ax = FetchRequest()
ax.add(AttrInfo(AXAttribute.CONTACT_EMAIL,
required=True))
auth_request.addExtension(ax)
callback_url = reverse(callback)
SocialLogin.stash_state(request)
redirect_url = auth_request.redirectURL(
request.build_absolute_uri('/'),
request.build_absolute_uri(callback_url))
return HttpResponseRedirect(redirect_url)
# UnicodeDecodeError: see https://github.com/necaris/python3-openid/issues/1
except (UnicodeDecodeError, DiscoveryFailure) as e:
if request.method == 'POST':
form._errors["openid"] = form.error_class([e])
else:
return render_authentication_error(request)
else:
form = LoginForm()
d = dict(form=form)
return render_to_response('openid/login.html',
d, context_instance=RequestContext(request))
def org_main(request):
data = {}
org_type_info = list()
title_link = reverse('create_lab')
title_link_text = '(add)'
for (slug, org_type_id) in models.ORG_TYPE_URL2ID:
cnt = models.Organization.objects.filter(
org_type = org_type_id
).count()
if cnt == 0:
continue
info = {
'url': reverse('org_list', kwargs = {'org_type': slug}),
'org_type_name': slug.replace('-', ' '),
'count': cnt
}
org_type_info.append(info)
data = {
'request': request,
'org_type_info': org_type_info,
'title': 'Organizations',
'title_link': title_link,
'title_link_text': title_link_text,
}
return render_to_response('org_main.html', data)
def signup(request, signup_form=SignupForm,
template_name='registration/signup_form.html',
success_url=None, extra_context=None):
if settings.BAPH_AUTH_WITHOUT_USERNAMES and (signup_form == SignupForm):
signup_form = SignupFormOnlyEmail
if request.method == 'POST':
form = signup_form(request.POST, request.FILES)
if form.is_valid():
user = form.save()
if success_url: redirect_to = success_url
else: redirect_to = reverse('baph_signup_complete')
# A new signed user should logout the old one.
if request.user.is_authenticated():
logout(request)
if (settings.BAPH_SIGNIN_AFTER_SIGNUP and
not settings.BAPH_ACTIVATION_REQUIRED):
user = authenticate(identification=user.email,
check_password=False)
login(request, user)
return redirect(redirect_to)
else:
form = signup_form()
if not extra_context: extra_context = dict()
extra_context['form'] = form
return render_to_response(template_name, extra_context,
context_instance=RequestContext(request))
def index(request):
info = request.GET.get('info', '').strip()
if info:
devices = Device.objects.filter(info__contains=info).order_by('group')
else:
devices = Device.objects.all().order_by('group')
return render_to_response('csp/device/index.html', {'devices':devices, 'info':info}, context_instance=RequestContext(request))
def game(request, game_id):
game = get_object_or_404(Game, pk=game_id)
teams = Team.objects.filter(game=game).order_by("-won")
players = []
for team in teams:
players += team.players.all()
players = sorted(players, (lambda x, y: cmp(x.name, y.name)))
numPlayers = len(players)
length = game.end_date - game.start_date
winners = teams.filter(won=True)
numWinners = teams.filter(won=True).count()
teams = [(team, team.players.all().order_by("name")) for team in teams]
roles = dict(((role.player.name, role) for role in Role.objects.filter(game=game)))
roleOrder = dict(((role[1].pk, index) for role, index in zip(roles.items(), range(len(roles)))))
can_edit = request.user.has_perm("mafiaStats.game")
return render_to_response(
"game.html",
{
"can_edit": can_edit,
"game": game,
"teams": teams,
"num_players": numPlayers,
"roleOrder": roleOrder,
"length": length,
"next": reverse("mafiastats_game", args=[int(game_id)]),
"players": players,
"winners": winners,
"roles": roles,
},
context_instance=RequestContext(request),
)
def index(request):
e = request.GET['e']
u= request.GET['u']
c ={
"e":e,
"u":u
}
return shortcuts.render_to_response("identities/list.html",c)
def search(request):
c = get_context(request, css_class='body-search', title='')
c['query'] = request.GET.get('q', '')
populate_latest_budget(c)
c['selected_year'] = str(request.GET.get('year', c['latest_budget'].year))
c['page'] = request.GET.get('page', 1)
c['query_string'] = "year=%s&q=%s&" % (c['selected_year'], c['query'])
# If no parameter is given we show results for the latest budget. In order
# to search across all budgets one needs to request that explicitly.
if c['selected_year'] != "all":
year = c['selected_year']
budgets = Budget.objects.filter(entity__id=get_main_entity(c).id, year=year)
budget = budgets[0] if len(budgets)>0 else None
else:
year = None
budget = None
# Get search results
c['years'] = map(str, Budget.objects.get_years())
c['terms'] = list(GlossaryTerm.objects.search(c['query']))
if not hasattr(settings, 'SEARCH_ENTITIES') or settings.SEARCH_ENTITIES:
c['entities'] = list(Entity.objects.search(c['query']))
c['show_entity_names'] = True
all_items = list(BudgetItem.objects.search(c['query'], year, c['page']))
try:
c['items'] = Paginator(all_items, 10).page(c['page'])
except EmptyPage:
pass
all_payments = list(Payment.objects.search(c['query'], year))
try:
c['payments'] = Paginator(all_payments, 10).page(c['page'])
except EmptyPage:
pass
# Consolidate policies and programmes search results, to avoid duplicates
# XXX: We're searching only in top-level entity, the other ones are spotty,
# not sure it's worth the effort; plus the search results UX is complicated.
policies = list(FunctionalCategory.objects.search_policies(c['query'], budget))
programmes = list(FunctionalCategory.objects.search_programmes(c['query'], budget))
c['policies_ids'] = list(set([policy.uid() for policy in policies]))
c['programmes_per_policy'] = {}
for programme in programmes:
if not c['programmes_per_policy'].get(programme.policy, None):
c['programmes_per_policy'][programme.policy] = set()
c['programmes_per_policy'][programme.policy].add(programme.programme)
c['results_size'] = len(c['terms']) + len(c['policies_ids']) + len(all_items) + len(all_payments)
c['formatter'] = add_thousands_separator
c['main_entity_level'] = settings.MAIN_ENTITY_LEVEL
# XXX: Note we only have top-level descriptions. Beware on the view not to use
# the wrong descriptions. We should fetch the descriptions from the DB together with
# the results if needed.
populate_descriptions(c)
# Count the size of the programme sets
for programmes in c['programmes_per_policy'].values():
c['results_size'] += len(programmes)
return render_to_response('search/index.html', c)
def login_cancelled(request):
d = {}
return render_to_response('socialaccount/login_cancelled.html',
d,
context_instance=RequestContext(request))
def edit(request):
id = request.REQUEST['id']
contact = InquireRecord.objects.get(id = id)
form=InquireRecordForm(instance =contact)
c ={"form":form,'id':id}
return shortcuts.render_to_response("Inquire/edit.html",c)
def edit(request):
id = request.REQUEST['id']
contact = Contact.objects.get(id=id)
form = ContactForm(instance=contact)
c = {"form": form, 'id': id}
return shortcuts.render_to_response("identities/edit.html", c)
def home(request):
""" Default view for the root """
return render_to_response('base/home.html',
context_instance=RequestContext(request))
def reuse(request):
c = get_context(request, css_class='body-reuse', title=_('Inicio'))
return render_to_response('reuse/index.html', c)
def render_to_html(request, template, variables):
variables['request'] = request
new_variables = variables
return render_to_response(template,
new_variables,
context_instance=RequestContext(request))
def index(request):
#form = InquireRecordForm()
#c ={"form":form}
return shortcuts.render_to_response("Inquire/list.html")
def render(c, render_callback, template_name):
if not render_callback:
return render_to_response(template_name, c)
else:
return render_callback.generate_response(c)
def guidedvisit(request, render_callback=None):
# Get request context
c = get_context(request, css_class='body-entities', title='')
return render_to_response('guidedvisit/index.html', c)
def report(request):
e = request.GET['e']
u= request.GET['u']
c ={
"e":e,
"u":u,
}
type = request.GET['type']
if(type =="edate"):
c["categories"] = ['0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', '10', '11', '12',
'13','14', '15', '16', '17', '18', '19',
'20','21', '22', '23']
from django.db import connection, transaction
cursor = connection.cursor()
cursor.execute("SELECT COUNT(*),date_format(callrecord.incomingtime,\"%%H\") as hour "
"FROM callrecord WHERE callrecord.agent = %s and callrecord.company = %s and TO_DAYS(callrecord.incomingtime) = TO_DAYS(NOW())"
"group by date_format(callrecord.incomingtime,\"%%H\")",[u,e])
row = cursor.fetchall()
c["seriescall"] = [0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0]
for v in row :
c["seriescall"][int(v[1])]= int(v[0])
return shortcuts.render_to_response("CallReport/list.html",c)
elif (type =="e30"):
c["categories"] = []
i = 14
while i>=0:
c["categories"].append((datetime.datetime.now() - datetime.timedelta(days = i)).strftime("%m-%d"))
i=i-1
from django.db import connection, transaction
cursor = connection.cursor()
cursor.execute("SELECT COUNT(*), date_format(callrecord.incomingtime,\"%%m-%%d\") as date "
"FROM callrecord "
"WHERE DATE_SUB(now(), INTERVAL 15 DAY) <= date(callrecord.incomingtime) and callrecord.agent = %s and callrecord.company = %s "
"group by date_format(callrecord.incomingtime,\"%%m-%%d\")",[u,e])
row = cursor.fetchall()
c["seriescall"] = [0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0]
for v in row :
catei = 0;
for cv in c["categories"]:
if(cv == v[1]):
c["seriescall"][catei] = int(v[0])
catei = catei+1
return shortcuts.render_to_response("CallReport/report30.html",c)
elif (type =="emonth"):
c["categories"] = []
i = 11
while i>=0:
c["categories"].append((datetime.datetime.now() - datetime.timedelta(days = i*30)).strftime("%y-%m"))
i=i-1
from django.db import connection, transaction
cursor = connection.cursor()
cursor.execute("SELECT COUNT(*), date_format(callrecord.incomingtime,\"%%y-%%m\") as date "
"FROM callrecord "
"WHERE DATE_SUB(now(), INTERVAL 12 MONTH) <= date(callrecord.incomingtime) and callrecord.agent = %s and callrecord.company = %s "
"group by date_format(callrecord.incomingtime,\"%%y-%%m\")",[u,e])
row = cursor.fetchall()
c["seriescall"] = [0,0,0,0,
0,0,0,0,
0,0,0,0]
for v in row :
catei = 0;
for cv in c["categories"]:
if(cv == v[1]):
c["seriescall"][catei] = int(v[0])
catei = catei+1
return shortcuts.render_to_response("CallReport/reportmonth.html",c)
return shortcuts.render_to_response("CallReport/reportmonth.html",c)
def index(request):
e = request.GET['e']
u = request.GET['u']
c = {"e": e, "u": u}
return shortcuts.render_to_response("CallRecord/list.html", c)
def index(request, content_type_id, object_pk):
comments = api.get_comments_limited(content_type_id, object_pk).order_by(
'-sortdate', 'path')
form = _get_comment_form(content_type_id, object_pk)
context = RequestContext(request, {'comments': comments, 'form': form})
return render_to_response('tcc/index.html', context)
def password_reset_done(request, **kwargs):
return render_to_response(
kwargs.pop("template_name", "account/password_reset_done.html"),
RequestContext(request, {}))
def replies(request, parent_id):
comments = api.get_comment_replies(parent_id)
context = RequestContext(request, {'comments': comments})
return render_to_response('tcc/replies.html', context)
def r2r(template, request, data=None):
if data is None:
data = {}
data['request'] = request
return render_to_response(template, data, context_instance=RequestContext(request))
