def stats(request):
user = get_user(request)
uuid = request.GET.get('uuid', None)
election = None
if uuid:
election = Election.objects.filter(uuid=uuid)
if not (user and user.superadmin_p):
election = election.filter(is_completed=True)
election = election.defer('encrypted_tally', 'result')[0]
if user and user.superadmin_p:
elections = Election.objects.filter(is_completed=True)
else:
elections = Election.objects.filter(is_completed=True)
elections = elections.order_by('-created_at').defer('encrypted_tally',
'result')
return render_template(request, 'zeus/stats', {'menu_active': 'stats',
'election': election,
'uuid': uuid,
'user': user,
'elections': elections})
def resources(request):
user = get_user(request)
MANUALS_URL = '/static/documentation/manuals/'
return render_template(request, "zeus/resources", {
'MANUALS_URL': MANUALS_URL,
'menu_active': 'resources',
'user': user})
def election_email_show(request):
if not request.method == 'POST':
raise PermissionDenied
uuid = request.POST.get('uuid', None)
code = request.POST.get('secret', None)
if not uuid or not code:
return HttpResponseRedirect(reverse('zeus.views.election_email_login',
kwargs={'uuid': uuid}) + "?bad_code=1")
try:
auth_code = SecretAuthcode.objects.get(election_uuid=uuid, code=code)
except SecretAuthcode.DoesNotExist:
return HttpResponseRedirect(reverse('zeus.views.election_email_login',
kwargs={'uuid': uuid}) + "?bad_code=1")
election = get_object_or_404(Election, uuid=uuid)
voter_o = election.voter_set.get(voter_login_id=auth_code.voter_login)
context = {'election': election, 'voter': voter_o}
email_content = render_to_string("email/vote_body.txt", context)
return render_template(request, 'zeus/election_email_show', {'menu_active': 'home',
'election_o': election,
'voter': voter_o,
'email_content': email_content})
def add_edit(request, election, poll=None):
admin = request.admin
if not poll and not election.feature_can_add_poll:
raise PermissionDenied
if poll and not poll.feature_can_edit:
raise PermissionDenied
if poll:
oldname = poll.name
if request.method == "POST":
form = PollForm(request.POST, instance=poll, election=election,
admin=admin)
if form.is_valid():
new_poll = form.save()
if form.has_changed():
new_poll.logger.info("Poll updated %r" % form.changed_data)
message = _("Poll updated successfully")
messages.success(request, message)
newname = new_poll.name
# log poll edit/creation
if poll:
if oldname != newname:
poll.logger.info("Renamed from %s to %s", oldname, newname)
else:
new_poll.logger.info("Poll created")
url = election_reverse(election, 'polls_list')
return redirect(url)
else:
form = PollForm(instance=poll, election=election, admin=admin)
context = {'election': election, 'poll': poll, 'form': form}
set_menu('polls', context)
if poll:
set_menu('edit_poll', context)
tpl = "election_poll_add_or_edit"
return render_template(request, tpl, context)
def faqs_voter(request):
user = request.zeususer
return render_template(request, "zeus/faqs_voter", {
'menu_active': 'faqs',
'submenu': 'voter',
'user': user
})
def questions(request, election, poll):
module = poll.get_module()
if request.zeususer.is_admin:
if not module.questions_set() and poll.feature_can_manage_questions:
url = poll_reverse(poll, 'questions_manage')
return HttpResponseRedirect(url)
preview_booth_url = poll.get_booth_url(request, preview=True)
linked_polls = None
if request.zeususer.is_voter and poll.is_linked_root:
linked_polls = poll.other_linked_polls
questions_tpl = \
getattr(module, 'questions_list_template', 'election_poll_questions') + ".html"
context = {
'election': election,
'poll': poll,
'questions': questions,
'module': poll.get_module(),
'preview_booth_url': preview_booth_url,
'questions_tpl': questions_tpl,
'linked_polls': linked_polls
}
set_menu('questions', context)
tpl = 'election_poll_questions_wrapper'
return render_template(request, tpl, context)
def add(request, election, poll=None):
if election.linked_polls and request.FILES.has_key('batch_file'):
return _add_batch(request, election)
if request.method == "GET":
url = election_reverse(election, 'polls_list')
return HttpResponseRedirect(url)
extra = int(request.GET.get('extra', 2))
polls_formset = modelformset_factory(Poll, PollForm, extra=extra,
max_num=100, formset=PollFormSet,
can_delete=False)
polls = Poll.objects.none()
form = polls_formset(request.POST, queryset=polls, election=election)
if form.is_valid():
with transaction.commit_on_success():
polls = form.save(election)
for poll in polls:
poll.logger.info("Poll created")
else:
polls = Poll.objects.filter(election=election)
context = {'polls': polls, 'election': election, 'form': form}
set_menu('polls', context)
return render_template(request, "election_polls_list", context)
url = election_reverse(election, 'polls_list')
return HttpResponseRedirect(url)
def reset_password(request):
uid = request.GET.get('uid')
uid = sanitize_get_param(uid)
user = get_user(uid)
context = {"u_data": user}
return render_template(request, 'account_administration/reset_password',
context)
def faqs_trustee(request):
user = request.zeususer
return render_template(request, "zeus/faqs_admin", {
'menu_active': 'faqs',
'submenu': 'admin',
'user': user
})
def audited_ballots(request, election, poll):
vote_hash = request.GET.get("vote_hash", None)
if vote_hash:
b = get_object_or_404(AuditedBallot, poll=poll, vote_hash=vote_hash)
b = AuditedBallot.objects.get(poll=poll, vote_hash=request.GET["vote_hash"])
return HttpResponse(b.raw_vote, mimetype="text/plain")
audited_ballots = AuditedBallot.objects.filter(is_request=False, poll=poll)
voter = None
if request.zeususer.is_voter:
voter = request.voter
voter_audited_ballots = []
if voter:
voter_audited_ballots = AuditedBallot.objects.filter(poll=poll, is_request=False, voter=voter)
context = {
"election": election,
"audited_ballots": audited_ballots,
"voter_audited_ballots": voter_audited_ballots,
"poll": poll,
"per_page": 50,
}
set_menu("audited_ballots", context)
return render_template(request, "election_poll_audited_ballots", context)
def faqs_trustee(request):
user = request.zeususer
return render_template(request, "zeus/faqs_admin", {
'menu_active': 'faqs',
'submenu': 'admin',
'user': user
})
def stats(request):
user = request.zeususer._user
if not request.zeususer.is_admin:
return HttpResponseRedirect(reverse('home'))
uuid = request.GET.get('uuid', None)
election = None
elections = Election.objects.filter()
if not (user and user.superadmin_p):
elections = Election.objects.filter(canceled_at__isnull=True,
completed_at__isnull=False,
voting_ended_at__isnull=False,
admins__in=[user],
trial=False)
elections = elections.order_by('-created_at')
if uuid:
try:
election = elections.get(uuid=uuid)
except Election.DoesNotExist:
return HttpResponseRedirect(reverse('home'))
return render_template(request, 'zeus/stats', {
'menu_active': 'stats',
'election': election,
'uuid': uuid,
'user': user,
'elections': elections
})
def stats(request):
user = request.zeususer._user
if not request.zeususer.is_admin:
return HttpResponseRedirect(reverse("home"))
uuid = request.GET.get("uuid", None)
election = None
elections = Election.objects.filter()
if not (user and user.superadmin_p):
elections = Election.objects.filter(
canceled_at__isnull=True,
completed_at__isnull=False,
voting_ended_at__isnull=False,
admins__in=[user],
trial=False,
)
elections = elections.order_by("-created_at")
if uuid:
try:
election = elections.get(uuid=uuid)
except Election.DoesNotExist:
return HttpResponseRedirect(reverse("home"))
return render_template(
request,
"zeus/stats",
{"menu_active": "stats", "election": election, "uuid": uuid, "user": user, "elections": elections},
)
def report(request, election, format):
reports_list = request.GET.get('report',
'election,voters,votes,results').split(",")
_reports = OrderedDict()
if 'election' in reports_list:
_reports['election'] = list(reports.election_report([election],
True, False))
if 'voters' in reports_list:
_reports['voters'] = list(reports.election_voters_report([election]))
if 'votes' in reports_list:
_reports['votes'] = list(reports.election_votes_report([election],
True, True))
if 'results' in reports_list:
_reports['results'] = list(reports.election_results_report([election]))
if format == "html":
return render_template(request, "election_report", {
'election': election,
'reports': _reports,
})
else:
def handler(obj):
if hasattr(obj, 'isoformat'):
return obj.isoformat()
raise TypeError
return HttpResponse(json.dumps(_reports, default=handler),
mimetype="application/json")
def audited_ballots(request, election, poll):
vote_hash = request.GET.get('vote_hash', None)
if vote_hash:
b = get_object_or_404(AuditedBallot, poll=poll, vote_hash=vote_hash)
b = AuditedBallot.objects.get(poll=poll,
vote_hash=request.GET['vote_hash'])
return HttpResponse(b.raw_vote, mimetype="text/plain")
audited_ballots = AuditedBallot.objects.filter(is_request=False, poll=poll)
voter = None
if request.zeususer.is_voter:
voter = request.voter
voter_audited_ballots = []
if voter:
voter_audited_ballots = AuditedBallot.objects.filter(poll=poll,
is_request=False,
voter=voter)
context = {
'election': election,
'audited_ballots': audited_ballots,
'voter_audited_ballots': voter_audited_ballots,
'poll': poll,
'per_page': 50
}
set_menu('audited_ballots', context)
return render_template(request, 'election_poll_audited_ballots', context)
def verify_key(request, election, trustee):
context = {
'election': election,
'trustee': trustee
}
election.reprove_trustee(trustee)
return render_template(request, 'election_trustee_check_sk', context)
def results(request, election, poll):
if not request.zeususer.is_admin and not poll.feature_public_results:
raise PermissionDenied('41')
context = {'poll': poll, 'election': election}
set_menu('results', context)
return render_template(request, 'election_poll_results', context)
def add_edit(request, election, poll=None):
if not poll and not election.feature_can_add_poll:
raise PermissionDenied
if election.linked_polls and request.FILES.has_key('batch_file'):
return _add_batch(request, election)
if poll:
oldname = poll.name
if request.method == "POST":
form = PollForm(request.POST, instance=poll, election=election)
if form.is_valid():
new_poll = form.save()
if form.has_changed():
new_poll.logger.info("Poll updated %r" % form.changed_data)
message = _("Poll updated successfully")
messages.success(request, message)
newname = new_poll.name
# log poll edit/creation
if poll:
if oldname != newname:
poll.logger.info("Renamed from %s to %s", oldname, newname)
else:
new_poll.logger.info("Poll created")
url = election_reverse(election, 'polls_list')
return redirect(url)
if request.method == "GET":
form = PollForm(instance=poll, election=election)
context = {'election': election, 'poll': poll, 'form': form}
set_menu('polls', context)
if poll:
set_menu('edit_poll', context)
tpl = "election_poll_add_or_edit"
return render_template(request, tpl, context)
def cast_done(request, election, poll):
if request.zeususer.is_authenticated() and request.zeususer.is_voter:
if poll.has_linked_polls:
voter = request.zeususer._user
next_poll = poll.next_linked_poll(voter_id=voter.voter_login_id)
if next_poll:
try:
voter = next_poll.voters.get(
voter_login_id=request.zeususer._user.voter_login_id)
user = auth.ZeusUser(voter)
user.authenticate(request)
url = next_poll.get_booth_url(request)
return HttpResponseRedirect(url)
except Voter.DoesNotExist:
pass
request.zeususer.logout(request)
fingerprint = request.GET.get('f')
if not request.GET.get('f', None):
raise PermissionDenied('39')
vote = get_object_or_404(CastVote, fingerprint=fingerprint)
return render_template(request, 'election_poll_cast_done', {
'cast_vote': vote,
'election_uuid': election.uuid,
'poll_uuid': poll.uuid
})
def questions(request, election, poll):
module = poll.get_module()
if request.zeususer.is_admin:
if not module.questions_set() and poll.feature_can_manage_questions:
url = poll_reverse(poll, 'questions_manage')
return HttpResponseRedirect(url)
preview_booth_url = poll.get_booth_url(request, preview=True)
linked_polls = None
if request.zeususer.is_voter and poll.is_linked_root:
linked_polls = poll.other_linked_polls
questions_tpl = \
getattr(module, 'questions_list_template', 'election_poll_questions') + ".html"
context = {
'election': election,
'poll': poll,
'questions': questions,
'module': poll.get_module(),
'preview_booth_url': preview_booth_url,
'questions_tpl': questions_tpl,
'linked_polls': linked_polls
}
set_menu('questions', context)
tpl = 'election_poll_questions_wrapper'
return render_template(request, tpl, context)
def audited_ballots(request, election, poll):
vote_hash = request.GET.get('vote_hash', None)
if vote_hash:
b = get_object_or_404(AuditedBallot, poll=poll, vote_hash=vote_hash)
b = AuditedBallot.objects.get(poll=poll,
vote_hash=request.GET['vote_hash'])
return HttpResponse(b.raw_vote, mimetype="text/plain")
audited_ballots = AuditedBallot.objects.filter(is_request=False,
poll=poll)
voter = None
if request.zeususer.is_voter:
voter = request.voter
voter_audited_ballots = []
if voter:
voter_audited_ballots = AuditedBallot.objects.filter(poll=poll,
is_request=False,
voter=voter)
context = {
'election': election,
'audited_ballots': audited_ballots,
'voter_audited_ballots': voter_audited_ballots,
'poll': poll,
'per_page': 50
}
set_menu('audited_ballots', context)
return render_template(request, 'election_poll_audited_ballots', context)
def create_usergroup(request):
groups = UserGroup.objects.all()
edit_id = sanitize_get_param(request.GET.get('edit_id'))
edit_group = None
if edit_id:
edit_group = get_object_or_404(UserGroup, id=edit_id)
logged_user = request.zeususer._user
if request.method == 'POST':
form = userGroupForm(request.POST, instance=edit_group)
if form.is_valid():
group = form.save()
if edit_group:
message = _("Changes on user group were successfully saved")
else:
message = _("Group %s was created" % (group.name))
messages.success(request, message)
url = reverse('list_usergroups')
return redirect(url)
if request.method == 'GET':
form = userGroupForm(instance=edit_group)
tpl = 'account_administration/create_usergroup',
context = {'form': form}
return render_template(request, tpl, context)
def results(request, election, poll):
if not request.zeususer.is_admin and not poll.feature_public_results:
raise PermissionDenied("41")
context = {"poll": poll, "election": election}
set_menu("results", context)
return render_template(request, "election_poll_results", context)
def resources(request):
user = request.zeususer
return render_template(request, "zeus/resources", {
'menu_active': 'resources',
'user': user,
'guides': site_guides
})
def add_edit(request, election, poll=None):
if not poll and not election.feature_can_add_poll:
raise PermissionDenied
if election.linked_polls and request.FILES.has_key("batch_file"):
return _add_batch(request, election)
if poll:
oldname = poll.name
if request.method == "POST":
form = PollForm(request.POST, instance=poll, election=election)
if form.is_valid():
new_poll = form.save()
if form.has_changed():
new_poll.logger.info("Poll updated %r" % form.changed_data)
message = _("Poll updated successfully")
messages.success(request, message)
newname = new_poll.name
# log poll edit/creation
if poll:
if oldname != newname:
poll.logger.info("Renamed from %s to %s", oldname, newname)
else:
new_poll.logger.info("Poll created")
url = election_reverse(election, "polls_list")
return redirect(url)
if request.method == "GET":
form = PollForm(instance=poll, election=election)
context = {"election": election, "poll": poll, "form": form}
set_menu("polls", context)
if poll:
set_menu("edit_poll", context)
tpl = "election_poll_add_or_edit"
return render_template(request, tpl, context)
def faqs_voter(request):
user = request.zeususer
return render_template(request, "zeus/faqs_voter", {
'menu_active': 'faqs',
'submenu': 'voter',
'user': user
})
def cast_done(request, election, poll):
if request.zeususer.is_authenticated() and request.zeususer.is_voter:
if poll.has_linked_polls:
voter = request.zeususer._user
next_poll = poll.next_linked_poll(voter_id=voter.voter_login_id)
if next_poll:
try:
voter = next_poll.voters.get(
voter_login_id=request.zeususer._user.voter_login_id)
user = auth.ZeusUser(voter)
user.authenticate(request)
url = next_poll.get_booth_url(request)
return HttpResponseRedirect(url)
except Voter.DoesNotExist:
pass
request.zeususer.logout(request)
fingerprint = request.GET.get('f')
if not request.GET.get('f', None):
raise PermissionDenied('39')
vote = get_object_or_404(CastVote, fingerprint=fingerprint)
return render_template(request, 'election_poll_cast_done', {
'cast_vote': vote,
'election_uuid': election.uuid,
'poll_uuid': poll.uuid
})
def stats(request):
user = request.zeususer._user
if not request.zeususer.is_admin:
return HttpResponseRedirect(reverse('home'))
uuid = request.GET.get('uuid', None)
election = None
elections = Election.objects.filter()
if not (user and user.superadmin_p):
elections = Election.objects.filter(canceled_at__isnull=True,
completed_at__isnull=False,
voting_ended_at__isnull=False,
admins__in=[user],
trial=False)
elections = elections.order_by('-created_at')
if uuid:
try:
election = elections.get(uuid=uuid)
except Election.DoesNotExist:
return HttpResponseRedirect(reverse('home'))
return render_template(
request, 'zeus/stats', {
'menu_active': 'stats',
'election': election,
'uuid': uuid,
'user': user,
'elections': elections
})
def report(request, election, format):
reports_list = request.GET.get('report',
'election,voters,votes,results').split(",")
_reports = OrderedDict()
if 'election' in reports_list:
_reports['election'] = list(
reports.election_report([election], True, False))
if 'voters' in reports_list:
_reports['voters'] = list(reports.election_voters_report([election]))
if 'votes' in reports_list:
_reports['votes'] = list(
reports.election_votes_report([election], True, True))
if 'results' in reports_list:
_reports['results'] = list(reports.election_results_report([election]))
if format == "html":
return render_template(request, "election_report", {
'election': election,
'reports': _reports,
})
else:
def handler(obj):
if hasattr(obj, 'isoformat'):
return obj.isoformat()
raise TypeError
return HttpResponse(json.dumps(_reports, default=handler),
content_type="application/json")
def index(request, election, poll=None):
user = request.zeususer
if poll:
election_url = poll.get_absolute_url()
else:
election_url = election.get_absolute_url()
booth_url = None
linked_booth_urls = []
if poll:
booth_url = poll.get_booth_url(request)
if poll.has_linked_polls and user.is_voter:
for p in poll.linked_polls:
if p == poll:
continue
try:
voter = \
p.voters.get(voter_login_id=user._user.voter_login_id)
except Exception as e:
continue
burl = reverse('election_poll_voter_booth_linked_login',
args=(
election.uuid,
poll.uuid,
voter.uuid,
))
burl = burl + "?link-to=%s" % p.uuid
linked_booth_urls.append((p.name, burl, voter.cast_at))
voter = None
votes = None
if user.is_voter:
# cast any votes?
voter = request.voter
votes = voter.get_cast_votes()
if election.frozen_at:
voter.last_visit = datetime.datetime.now()
voter.save()
else:
votes = None
trustees = election.trustees.filter()
context = {
'election': election,
'poll': poll,
'trustees': trustees,
'user': user,
'votes': votes,
'election_url': election_url,
'booth_url': booth_url,
'linked_booth_urls': linked_booth_urls
}
if poll:
context['poll'] = poll
set_menu('election', context)
return render_template(request, 'election_view', context)
def questions_update_view(self, request, election, poll):
from zeus.utils import poll_reverse
from zeus.forms import PartyForm, DEFAULT_ANSWERS_COUNT, \
MAX_QUESTIONS_LIMIT
extra = 1
if poll.questions_data:
extra = 0
questions_formset = formset_factory(PartyForm,
extra=extra,
can_delete=True,
can_order=True)
if request.method == 'POST':
formset = questions_formset(request.POST)
if formset.is_valid():
questions_data = []
for question in formset.cleaned_data:
if not question:
continue
# force sort of answers by extracting index from answer key.
# cast answer index to integer, otherwise answer_10 would
# be placed before answer_2
answer_index = lambda a: int(a[0].replace('answer_', ''))
isanswer = lambda a: a[0].startswith('answer_')
answer_values = list(
filter(isanswer, iter(question.items())))
sorted_answers = sorted(answer_values, key=answer_index)
answers = [x[1] for x in sorted_answers]
question['answers'] = answers
for k in list(question.keys()):
if k in ['DELETE', 'ORDER']:
del question[k]
questions_data.append(question)
poll.questions_data = questions_data
poll.update_answers()
poll.logger.info("Poll ballot updated")
poll.save()
url = poll_reverse(poll, 'questions')
return HttpResponseRedirect(url)
else:
formset = questions_formset(initial=poll.questions_data)
context = {
'default_answers_count': DEFAULT_ANSWERS_COUNT,
'formset': formset,
'max_questions_limit': MAX_QUESTIONS_LIMIT,
'election': election,
'poll': poll,
'module': self
}
set_menu('questions', context)
tpl = 'election_modules/parties/election_poll_questions_manage'
return render_template(request, tpl, context)
def home(request):
user = request.zeususer
bad_login = request.GET.get('bad_login')
return render_template(request, "zeus/home", {
'menu_active': 'home',
'user': user,
'bad_login': bad_login
})
def home(request, election, trustee):
context = {'election': election, 'trustee': trustee}
if not trustee.public_key:
url = election_reverse(election, 'trustee_keygen')
return HttpResponseRedirect(url)
set_menu('trustee', context)
return render_template(request, 'election_trustee_home', context)
def home(request):
user = request.zeususer
bad_login = request.GET.get('bad_login')
return render_template(request, "zeus/home", {
'menu_active': 'home',
'user': user,
'bad_login': bad_login
})
def voters_list(request, election, poll):
# for django pagination support
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 10))
q_param = request.GET.get('q', '')
default_voters_per_page = getattr(settings, 'ELECTION_VOTERS_PER_PAGE',
100)
voters_per_page = request.GET.get('limit', default_voters_per_page)
try:
voters_per_page = int(voters_per_page)
except:
voters_per_page = default_voters_per_page
order_by = request.GET.get('order', 'voter_login_id')
order_type = request.GET.get('order_type', 'desc')
table_headers = copy.copy(VOTER_TABLE_HEADERS)
if not order_by in table_headers:
order_by = 'voter_login_id'
if not poll.voters.filter(voter_weight__gt=1).count():
table_headers.pop('voter_weight')
display_weight_col = 'voter_weight' in table_headers
validate_hash = request.GET.get('vote_hash', "").strip()
hash_invalid = None
hash_valid = None
if (order_type == 'asc') or (order_type == None):
voters = Voter.objects.filter(poll=poll).annotate(
cast_votes__id=Max('cast_votes__id')).order_by(order_by)
else:
order_by = '-%s' % order_by
voters = Voter.objects.filter(poll=poll).annotate(
cast_votes__id=Max('cast_votes__id')).order_by(order_by)
voters = voters.filter(
get_filters(q_param, VOTER_TABLE_HEADERS, VOTER_SEARCH_FIELDS,
VOTER_BOOL_KEYS_MAP, VOTER_EXTRA_HEADERS))
voters_count = Voter.objects.filter(poll=poll).count()
voted_count = poll.voters_cast_count()
nr_voters_excluded = voters.excluded().count()
context = {
'election': election,
'poll': poll,
'page': page,
'voters': voters,
'voters_count': voters_count,
'voted_count': voted_count,
'q': q_param,
'voters_list_count': voters.count(),
'voters_per_page': voters_per_page,
'display_weight_col': display_weight_col,
'voter_table_headers': table_headers.iteritems(),
'nr_voters_excluded': nr_voters_excluded,
}
set_menu('voters', context)
return render_template(request, 'election_poll_voters_list', context)
def voters_list(request, election, poll):
# for django pagination support
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 10))
q_param = request.GET.get('q','')
default_voters_per_page = getattr(settings, 'ELECTION_VOTERS_PER_PAGE', 100)
voters_per_page = request.GET.get('limit', default_voters_per_page)
try:
voters_per_page = int(voters_per_page)
except:
voters_per_page = default_voters_per_page
order_by = request.GET.get('order', 'voter_login_id')
order_type = request.GET.get('order_type', 'desc')
module = election.get_module()
table_headers = copy.copy(module.get_voters_list_headers(request))
if not order_by in table_headers:
order_by = 'voter_login_id'
if not poll.voters.filter(voter_weight__gt=1).count():
table_headers.pop('voter_weight')
display_weight_col = 'voter_weight' in table_headers
if not poll.forum_enabled:
table_headers.pop('forum')
validate_hash = request.GET.get('vote_hash', "").strip()
hash_invalid = None
hash_valid = None
if (order_type == 'asc') or (order_type == None) :
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max('cast_votes__id')).order_by(order_by)
else:
order_by = '-%s' % order_by
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max('cast_votes__id')).order_by(order_by)
voters = module.filter_voters(voters, q_param, request)
voters_count = Voter.objects.filter(poll=poll).count()
voted_count = poll.voters_cast_count()
nr_voters_excluded = voters.excluded().count()
context = {
'election': election,
'poll': poll,
'page': page,
'voters': voters,
'voters_count': voters_count,
'voted_count': voted_count,
'q': q_param,
'voters_list_count': voters.count(),
'voters_per_page': voters_per_page,
'display_weight_col': display_weight_col,
'voter_table_headers': table_headers,
'voter_table_headers_iter': table_headers.iteritems(),
'nr_voters_excluded': nr_voters_excluded,
}
set_menu('voters', context)
return render_template(request, 'election_poll_voters_list', context)
def keygen(request, election, trustee):
eg_params_json = json.dumps(ELGAMAL_PARAMS_LD_OBJECT.toJSONDict(),
sort_keys=True)
context = {
'eg_params_json': eg_params_json,
'election': election,
'trustee': trustee
}
return render_template(request, "election_trustee_keygen", context)
def terms(request):
terms_file = getattr(settings, 'ZEUS_TERMS_FILE', None)
if terms_file is None:
return HttpResponseRedirect(reverse('home'))
with open(terms_file % {'lang': get_language()}, "r") as terms_fd:
terms_contents = terms_fd.read()
return render_template(request, "zeus/terms", {'content': terms_contents})
def reset_password(request):
uid = request.GET.get('uid')
uid = sanitize_get_param(uid)
user = get_user(uid)
context = {"u_data": user}
return render_template(
request,
'account_administration/reset_password',
context)
def keygen(request, election, trustee):
eg_params_json = simplejson.dumps(ELGAMAL_PARAMS_LD_OBJECT.toJSONDict(),
sort_keys=True)
context = {
'eg_params_json': eg_params_json,
'election': election,
'trustee': trustee
}
return render_template(request, "election_trustee_keygen", context)
def questions_update_view(self, request, election, poll):
from zeus.utils import poll_reverse
from zeus.forms import PartyForm, DEFAULT_ANSWERS_COUNT, \
MAX_QUESTIONS_LIMIT
extra = 1
if poll.questions_data:
extra = 0
questions_formset = formset_factory(PartyForm, extra=extra,
can_delete=True, can_order=True)
if request.method == 'POST':
formset = questions_formset(request.POST)
if formset.is_valid():
questions_data = []
for question in formset.cleaned_data:
if not question:
continue
# force sort of answers by extracting index from answer key.
# cast answer index to integer, otherwise answer_10 would
# be placed before answer_2
answer_index = lambda a: int(a[0].replace('answer_', ''))
isanswer = lambda a: a[0].startswith('answer_')
answer_values = filter(isanswer, question.iteritems())
sorted_answers = sorted(answer_values, key=answer_index)
answers = [x[1] for x in sorted_answers]
question['answers'] = answers
for k in question.keys():
if k in ['DELETE', 'ORDER']:
del question[k]
questions_data.append(question)
poll.questions_data = questions_data
poll.update_answers()
poll.logger.info("Poll ballot updated")
poll.save()
url = poll_reverse(poll, 'questions')
return HttpResponseRedirect(url)
else:
formset = questions_formset(initial=poll.questions_data)
context = {
'default_answers_count': DEFAULT_ANSWERS_COUNT,
'formset': formset,
'max_questions_limit': MAX_QUESTIONS_LIMIT,
'election': election,
'poll': poll,
'module': self
}
set_menu('questions', context)
tpl = 'election_modules/parties/election_poll_questions_manage'
return render_template(request, tpl, context)
def results(request, election, poll):
if not request.zeususer.is_admin and not poll.feature_public_results:
raise PermissionDenied('41')
context = {
'poll': poll,
'election': election
}
set_menu('results', context)
return render_template(request, 'election_poll_results', context)
def terms(request):
terms_file = getattr(settings, "ZEUS_TERMS_FILE", None)
if terms_file is None:
return HttpResponseRedirect(reverse("home"))
terms_fd = file(terms_file % {"lang": get_language()}, "r")
terms_contents = terms_fd.read()
terms_fd.close()
return render_template(request, "zeus/terms", {"content": terms_contents})
def voters_list(request, election, poll):
# for django pagination support
page = int(request.GET.get("page", 1))
limit = int(request.GET.get("limit", 10))
q_param = request.GET.get("q", "")
default_voters_per_page = getattr(settings, "ELECTION_VOTERS_PER_PAGE", 100)
voters_per_page = request.GET.get("limit", default_voters_per_page)
try:
voters_per_page = int(voters_per_page)
except:
voters_per_page = default_voters_per_page
order_by = request.GET.get("order", "voter_login_id")
order_type = request.GET.get("order_type", "desc")
table_headers = copy.copy(VOTER_TABLE_HEADERS)
if not order_by in table_headers:
order_by = "voter_login_id"
if not poll.voters.filter(voter_weight__gt=1).count():
table_headers.pop("voter_weight")
display_weight_col = "voter_weight" in table_headers
validate_hash = request.GET.get("vote_hash", "").strip()
hash_invalid = None
hash_valid = None
if (order_type == "asc") or (order_type == None):
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max("cast_votes__id")).order_by(order_by)
else:
order_by = "-%s" % order_by
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max("cast_votes__id")).order_by(order_by)
voters = voters.filter(
get_filters(q_param, VOTER_TABLE_HEADERS, VOTER_SEARCH_FIELDS, VOTER_BOOL_KEYS_MAP, VOTER_EXTRA_HEADERS)
)
voters_count = Voter.objects.filter(poll=poll).count()
voted_count = poll.voters_cast_count()
nr_voters_excluded = voters.excluded().count()
context = {
"election": election,
"poll": poll,
"page": page,
"voters": voters,
"voters_count": voters_count,
"voted_count": voted_count,
"q": q_param,
"voters_list_count": voters.count(),
"voters_per_page": voters_per_page,
"display_weight_col": display_weight_col,
"voter_table_headers": table_headers.iteritems(),
"nr_voters_excluded": nr_voters_excluded,
}
set_menu("voters", context)
return render_template(request, "election_poll_voters_list", context)
def voters_list(request, election, poll):
# for django pagination support
page = int(request.GET.get('page', 1))
limit = int(request.GET.get('limit', 10))
q_param = request.GET.get('q','')
default_voters_per_page = getattr(settings, 'ELECTION_VOTERS_PER_PAGE', 100)
voters_per_page = request.GET.get('limit', default_voters_per_page)
try:
voters_per_page = int(voters_per_page)
except:
voters_per_page = default_voters_per_page
order_by = request.GET.get('order', 'voter_login_id')
order_type = request.GET.get('order_type', 'desc')
table_headers = copy.copy(VOTER_TABLE_HEADERS)
if not order_by in table_headers:
order_by = 'voter_login_id'
if not poll.voters.filter(voter_weight__gt=1).count():
table_headers.pop('voter_weight')
display_weight_col = 'voter_weight' in table_headers
validate_hash = request.GET.get('vote_hash', "").strip()
hash_invalid = None
hash_valid = None
if (order_type == 'asc') or (order_type == None) :
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max('cast_votes__id')).order_by(order_by)
else:
order_by = '-%s' % order_by
voters = Voter.objects.filter(poll=poll).annotate(cast_votes__id=Max('cast_votes__id')).order_by(order_by)
voters = voters.filter(get_filters(q_param, VOTER_TABLE_HEADERS,
VOTER_SEARCH_FIELDS,
VOTER_BOOL_KEYS_MAP,
VOTER_EXTRA_HEADERS))
voters_count = Voter.objects.filter(poll=poll).count()
voted_count = poll.voters_cast_count()
context = {
'election': election,
'poll': poll,
'page': page,
'voters': voters,
'voters_count': voters_count,
'voted_count': voted_count,
'q': q_param,
'voters_list_count': voters.count(),
'voters_per_page': voters_per_page,
'display_weight_col': display_weight_col,
'voter_table_headers': table_headers.iteritems()
}
set_menu('voters', context)
return render_template(request, 'election_poll_voters_list', context)
def error(request, code=None, message=None, type="error"):
user = request.zeususer
messages_len = len(messages.get_messages(request))
if not messages_len and not message:
return HttpResponseRedirect(reverse("home"))
response = render_template(
request, "zeus/error", {"code": code, "error_message": message, "error_type": type, "user": user}
)
response.status_code = int(code)
return response
def results(request, election, poll):
if not request.zeususer.is_admin and not poll.feature_public_results:
raise PermissionDenied('41')
if not poll.get_module().display_poll_results:
url = election_reverse(election, 'index')
return HttpResponseRedirect(url)
context = {'poll': poll, 'election': election}
set_menu('results', context)
return render_template(request, 'election_poll_results', context)
def home(request, election, trustee):
context = {
'election': election,
'trustee': trustee
}
if not trustee.public_key:
url = election_reverse(election, 'trustee_keygen')
return HttpResponseRedirect(url)
set_menu('trustee', context)
return render_template(request, 'election_trustee_home', context)
def list(request, election):
polls = election.polls.filter()
extra = int(request.GET.get('extra', 1))
polls_formset = modelformset_factory(Poll, PollForm, extra=extra,
max_num=100, formset=PollFormSet,
can_delete=False)
add_polls = Poll.objects.none()
form = polls_formset(queryset=add_polls)
context = {'polls': polls, 'election': election, 'form': form}
set_menu('polls', context)
return render_template(request, "election_polls_list", context)
def voters_list(request, election, poll):
# for django pagination support
page = int(request.GET.get('page', 1))
q_param = request.GET.get('q', '')
default_voters_per_page = getattr(settings, 'ELECTION_VOTERS_PER_PAGE',
100)
voters_per_page = request.GET.get('limit', default_voters_per_page)
try:
voters_per_page = int(voters_per_page)
except ValueError:
voters_per_page = default_voters_per_page
order_by = request.GET.get('order', 'voter_login_id')
order_type = request.GET.get('order_type', 'desc')
module = election.get_module()
table_headers = copy.copy(module.get_voters_list_headers(request))
if order_by not in table_headers:
order_by = 'voter_login_id'
if not poll.voters.filter(voter_weight__gt=1).count():
table_headers.pop('voter_weight')
display_weight_col = 'voter_weight' in table_headers
if (order_type == 'asc') or (order_type is None):
voters = Voter.objects.filter(poll=poll).annotate(
cast_votes__id=Max('cast_votes__id')).order_by(order_by)
else:
order_by = '-%s' % order_by
voters = Voter.objects.filter(poll=poll).annotate(
cast_votes__id=Max('cast_votes__id')).order_by(order_by)
voters = module.filter_voters(voters, q_param, request)
voters_count = Voter.objects.filter(poll=poll).count()
voted_count = poll.voters_cast_count()
nr_voters_excluded = voters.excluded().count()
context = {
'election': election,
'poll': poll,
'page': page,
'voters': voters,
'voters_count': voters_count,
'voted_count': voted_count,
'q': q_param,
'voters_list_count': voters.count(),
'voters_per_page': voters_per_page,
'display_weight_col': display_weight_col,
'voter_table_headers': table_headers,
'voter_table_headers_iter': iter(table_headers.items()),
'nr_voters_excluded': nr_voters_excluded,
}
set_menu('voters', context)
return render_template(request, 'election_poll_voters_list', context)
def add_or_update(request, election=None):
user = request.admin
institution = user.institution
if request.method == "GET":
election_form = ElectionForm(user,
institution,
instance=election,
lang=request.LANGUAGE_CODE)
else:
election_form = ElectionForm(user,
institution,
request.POST,
instance=election)
if election_form.is_valid():
creating = election is None
with transaction.atomic():
election = election_form.save()
if not election.admins.filter(pk=user.pk).count():
election.admins.add(user)
if election_form.creating:
election.logger.info("Election created")
msg = "New election created"
subject = "New Zeus election"
election.notify_admins(msg=msg, subject=subject)
if not election.has_helios_trustee():
election.generate_trustee()
if election.polls.count() == 0:
url = election_reverse(election, 'polls_add')
else:
url = election_reverse(election, 'index')
if election.voting_extended_until:
subject = "Voting extension"
msg = "Voting end date extended"
election.notify_admins(msg=msg, subject=subject)
election.zeus.compute_election_public()
election.logger.info("Public key updated")
hook_url = None
if creating:
hook_url = election.get_module().run_hook('post_create')
else:
hook_url = election.get_module().run_hook('post_update')
return HttpResponseRedirect(hook_url or url)
context = {'election_form': election_form, 'election': election}
set_menu('election_edit', context)
tpl = "election_new"
if election and election.pk:
tpl = "election_edit"
return render_template(request, tpl, context)
def voters_upload(request, election, poll):
upload = poll.voter_file_processing()
common_context = {
'election': election,
'poll': poll,
'encodings': ENCODINGS,
'running_file': upload
}
if upload:
messages.warning(request, _("A voters import is already in progress."))
set_menu('voters', common_context)
if request.method == "POST":
preferred_encoding = request.POST.get('encoding', None)
if preferred_encoding not in dict(ENCODINGS):
messages.error(request, _("Invalid encoding"))
url = poll_reverse(poll, 'voters_upload')
return HttpResponseRedirect(url)
else:
common_context['preferred_encoding'] = preferred_encoding
if request.FILES.has_key('voters_file'):
voters_file = request.FILES['voters_file']
voter_file_obj = poll.add_voters_file(voters_file, encoding=preferred_encoding)
else:
error = _("No file uploaded")
messages.error(request, error)
url = poll_reverse(poll, 'voters_upload')
return HttpResponseRedirect(url)
try:
voter_file_obj.validate_process()
except (exceptions.VoterLimitReached, \
exceptions.DuplicateVoterID, ValidationError) as e:
messages.error(request, e.message)
voter_file_obj.delete()
url = poll_reverse(poll, 'voters_upload')
return HttpResponseRedirect(url)
poll.logger.info("Submitting voter file: %r", voter_file_obj.pk)
tasks.process_voter_file.delay(voter_file_obj.pk)
url = poll_reverse(poll, 'voters_upload_status', pk=voter_file_obj.pk)
return HttpResponseRedirect(url)
else:
if 'voter_file_id' in request.session:
del request.session['voter_file_id']
no_link = request.GET.get("no-link", False) != False
request.session['no_link'] = no_link
return render_template(request,
'election_poll_voters_upload',
common_context)
def voter_login(request):
form_cls = VoterLoginForm
form = VoterLoginForm()
if request.method == "POST":
form = VoterLoginForm(request.POST)
if form.is_valid():
poll = form._voter.poll
user = auth.ZeusUser(form._voter)
user.authenticate(request)
poll.logger.info("Poll voter '%s' logged in (global login view)", form._voter.voter_login_id)
return HttpResponseRedirect(poll_reverse(poll, "index"))
cxt = {"form": form}
return render_template(request, "voter_login", cxt)
def error(request, code=None, message=None, type='error'):
user = getattr(request, 'zeususer', ZeusUser.from_request(request))
messages_len = len(messages.get_messages(request))
if not messages_len and not message:
return HttpResponseRedirect(reverse('home'))
response = render_template(request, "zeus/error", {
'code': code,
'error_message': message,
'error_type': type,
'user': user,
})
response.status_code = int(code)
return response
def voter_login(request):
form = VoterLoginForm()
if request.method == 'POST':
form = VoterLoginForm(request.POST)
if form.is_valid():
poll = form._voter.poll
user = auth.ZeusUser(form._voter)
user.authenticate(request)
poll.logger.info("Poll voter '%s' logged in (global login view)",
form._voter.voter_login_id)
return HttpResponseRedirect(poll_reverse(poll, 'index'))
cxt = {'form': form}
return render_template(request, 'voter_login', cxt)
def jwt_login(request):
if not JWT_SUPPORT:
logger.error("JWT login not supported")
return HttpResponseRedirect(reverse("home"))
token = request.GET.get('jwt', None)
if not token:
message = "No json web token provided"
messages.error(request, message)
return redirect('home')
AUDIENCE = 'zeus' # add to settings
try:
data = jwt.decode(token, verify=False)
except (jwt.InvalidTokenError, ValueError) as error:
messages.error(request, error)
return redirect('home')
voter = None
iss = data.get('iss', None)
voter_email = data.get('sub', None)
if not (iss and voter_email):
error = "No iss or sub in token"
messages.error(request, error)
return redirect('home')
polls = Poll.objects.filter(jwt_auth=True,
jwt_issuer=iss,
voters__voter_email=voter_email)
allowed_polls = []
for poll in polls:
jwt_pk = poll.jwt_public_key
try:
jwt.decode(token, key=jwt_pk, audience=AUDIENCE, verify=True)
except (jwt.InvalidTokenError, ValueError) as error:
messages.error(request, error)
return redirect('home')
allowed_polls.append(poll)
polls_data = []
for poll in allowed_polls:
data = [poll]
voter = poll.voters.get(voter_email=voter_email)
voter_link = voter.get_quick_login_url()
data.append(voter_link)
polls_data.append(data)
context = {'issuer': iss, 'voter_data': voter, 'polls_data': polls_data}
tpl = 'jwt_polls_list'
return render_template(request, tpl, context)
def list_institutions(request):
institutions = Institution.objects.all()
institutions = institutions.order_by('id')
#filtering
inst_name = request.GET.get('inst_name')
if inst_name:
institutions = institutions.filter(name__icontains=inst_name)
context = {
'paginate_by': 10,
'inst_name': inst_name,
'institutions': institutions,
'request': request
}
return render_template(request, 'account_administration/list_institutions',
context)
def manage_user(request):
users = User.objects.all()
uid = request.GET.get('uid')
uid = sanitize_get_param(uid)
if request.zeususer._user.management_p:
user_type = 'manager'
if request.zeususer._user.superadmin_p:
user_type = 'superadmin'
user = get_user(uid)
if not user:
message = _("You didn't choose a user")
messages.error(request, message)
context = {'u_data': user, 'user_type': user_type}
return render_template(request, 'account_administration/user_manage',
context)
def password_login_view(request):
error = None
if request.method == "GET":
form = LoginForm()
else:
form = LoginForm(request.POST)
request.session['auth_system_name'] = 'password'
if request.method == "POST":
if form.is_valid():
request.session[auth.USER_SESSION_KEY] = form._user_cache.pk
logger.info("User %s logged in", form._user_cache.user_id)
return HttpResponseRedirect(reverse('admin_home'))
return render_template(request, 'login', {'form': form, 'error': error})
def questions(request, election, poll):
module = poll.get_module()
if request.zeususer.is_admin:
if not module.questions_set() and poll.feature_can_manage_questions:
url = poll_reverse(poll, 'questions_manage')
return HttpResponseRedirect(url)
preview_booth_url = poll.get_booth_url(request, preview=True)
context = {
'election': election,
'poll': poll,
'questions': questions,
'module': poll.get_module(),
'preview_booth_url': preview_booth_url
}
set_menu('questions', context)
tpl = getattr(module, 'questions_list_template', 'election_poll_questions')
return render_template(request, tpl, context)
