def addVoting(request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = VotingForm(request.POST,user=request.user)
# check whether it's valid:
if form.is_valid():
vot = form.save(commit=False);
vot.moderator = UserProfile.objects.filter(user=request.user)[0]
vot.save() ## zrobic zapisywanie wiele do wielu
for k in form.cleaned_data['kandydaci']:
kan = Candidate(glosowanie=vot,osoba=k)
kan.save()
for u in form.cleaned_data['uprawnieni']:
upr = Voter(glosowanie=vot,osoba=u)
upr.save()
#form.save_m2m() ## zamiast tego dodac reczny zapis do bazy
return render(request, 'AddVotingSuccess.html')
# if a GET (or any other method) we'll create a blank form
else:
form = VotingForm(user=request.user)
#form.fields["kandydaci"].queryset = UserProfile.objects.exclude(user=request.user) ##modyfikujemy liste kandydatow
return render(request, 'addVoting.html', {'regform': form,})
def voting_edit(request,vot_id):
#zabezpieczenie przed edycja glosowanie juz rozpoczetego oraz glosowania,ktorego nie jestesmy wlascicielami
voting = get_object_or_404(Voting, pk=vot_id,moderator__user=request.user,od__gt =timezone.now().date()) #zmiana na date()
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = VotingForm(request.POST,instance=voting,user=request.user)
# check whether it's valid:
if form.is_valid():
vot = form.save(commit=False);
vot.save()
vot.candidate_set.all().delete()
vot.voter_set.all().delete()
for k in form.cleaned_data['kandydaci']:
kan = Candidate(glosowanie=vot,osoba=k)
kan.save()
for u in form.cleaned_data['uprawnieni']:
upr = Voter(glosowanie=vot,osoba=u)
upr.save()
#form.save_m2m() ## zamiast tego dodac reczny zapis do bazy
return render(request, 'editVotingSuccess.html')
# if a GET (or any other method) we'll create a blank form
else:
form = VotingForm(instance=voting,user=request.user)
#form.fields["kandydaci"].queryset = UserProfile.objects.exclude(user=request.user) ##modyfikujemy liste kandydatow
return render(request, 'editVoting.html', {'regform': form,'vot_id':voting.id})
def polling_station_vote(ballot_id):
ballot = db.session.query(Ballot).get(ballot_id)
if ballot is None:
abort(404)
permit_voting(ballot)
input_options = pickle.loads(request.form["input_options_data"])
try:
validate_options(input_options, ballot)
except ValidationError as e:
flash(unicode(e), "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
except ValueError as e:
flash(u"Některý z hlasů má neplatnou hodnotu", "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
try:
vote_timestamp = session.get("vote_timestamp_{}".format(ballot_id),
False)
if not vote_timestamp:
raise ValidationError()
hash_base = compute_hash_base(ballot_id, g.user.id, input_options,
vote_timestamp)
hash_salt = request.form["hash_salt"]
h = hashlib.sha1()
h.update(hash_base.encode("utf-8"))
h.update(hash_salt.encode("utf-8"))
hash_digest = h.hexdigest()
except Exception as e:
flash(u"Chyba při výpočtu kontrolního řetězce", "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
for (option_id, value) in input_options.items():
vote = Vote()
vote.ballot_option_id = option_id
vote.value = value
vote.hash_digest = hash_digest
db.session.add(vote)
voter = Voter()
voter.ballot_id = ballot_id
voter.name = g.user.name
voter.email = g.user.email
voter.person_id = g.user.id
voter.voted_at = datetime.datetime.now()
voter.remote_addr = request.remote_addr
voter.user_agent = request.user_agent.string
db.session.add(voter)
send_mail = "send_confirmation_email" in request.form
email_body = send_vote_confirmation(ballot, voter, hash_digest, hash_salt,
vote_timestamp, send_mail)
db.session.commit()
return render_template('polling_station_vote.html',
ballot=ballot,
hash_digest=hash_digest,
email_body=email_body,
really_send=send_mail)
def post(self, request, advise):
ad = get_object_or_404(Advise, id=advise)
sid = request.session.session_key
v = Voter.objects.filter(ad=ad, sid=sid)
if not v.count():
if 'p1' in request.POST:
ad.votes += 1
elif 'm1' in request.POST:
ad.votes -= 1
ad.save()
v = Voter(ad=ad, sid=sid)
v.save()
return redirect(why, ad.happy.id)
def polling_station_vote(ballot_id):
ballot = db.session.query(Ballot).get(ballot_id)
if ballot is None:
abort(404)
permit_voting(ballot)
input_options = pickle.loads(request.form["input_options_data"])
try:
validate_options(input_options, ballot)
except ValidationError as e:
flash(unicode(e), "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
except ValueError as e:
flash(u"Některý z hlasů má neplatnou hodnotu", "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
try:
vote_timestamp = session.get(
"vote_timestamp_{}".format(ballot_id), False)
if not vote_timestamp:
raise ValidationError()
hash_base = compute_hash_base(ballot_id, g.user.id,
input_options, vote_timestamp)
hash_salt = request.form["hash_salt"]
h = hashlib.sha1()
h.update(hash_base.encode("utf-8"))
h.update(hash_salt.encode("utf-8"))
hash_digest = h.hexdigest()
except Exception as e:
flash(u"Chyba při výpočtu kontrolního řetězce", "danger")
return redirect(url_for('polling_station_item', ballot_id=ballot_id))
for (option_id, value) in input_options.items():
vote = Vote()
vote.ballot_option_id = option_id
vote.value = value
vote.hash_digest = hash_digest
db.session.add(vote)
voter = Voter()
voter.ballot_id = ballot_id
voter.name = g.user.name
voter.email = g.user.email
voter.person_id = g.user.id
voter.voted_at = datetime.datetime.now()
voter.remote_addr = request.remote_addr
voter.user_agent = request.user_agent.string
db.session.add(voter)
send_mail = "send_confirmation_email" in request.form
email_body = send_vote_confirmation(ballot, voter, hash_digest,
hash_salt, vote_timestamp, send_mail)
db.session.commit()
return render_template(
'polling_station_vote.html', ballot=ballot,
hash_digest=hash_digest, email_body=email_body, really_send=send_mail)
def login():
form = LogInForm()
if request.method == 'GET':
return render_template('login.html', form=form)
elif request.method == 'POST':
if form.validate_on_submit():
try:
conn = mysql.connect()
cursor = conn.cursor()
cursor.callproc('ValidateLogin', (form.email.data, ))
rv = cursor.fetchall()
finally:
conn.commit()
conn.close()
print len(rv)
if len(rv) != 0:
if check_password_hash(str(rv[0][2]), form.password.data):
voter = Voter(rv[0][0], rv[0][1])
login_user(voter)
return redirect(url_for('showAGMs'))
else:
return "Wrong password"
else:
return "user doesn't exist"
else:
return "form not validated"
else:
return "form not validated"
def find_voter(self, voterid):
voter = Voter.find(voterid)
if voter:
logger.info("%s - match found", voterid)
else:
logger.info("%s - no match found", voterid)
return voter
def add_voter():
voter_name = request.form['voter_name']
if not voter_name:
flash("Please enter a Voter Name.")
return render_template("add-voter.html", voters=voters)
else:
newVoter = Voter(voter_name)
db.session.add(newVoter)
db.session.commit()
flash("Voter added to Database.")
return redirect("/add-voters")
def load_user(vid):
try:
conn = mysql.connect()
cursor = conn.cursor()
cursor.callproc('GetByVoterID', (vid, ))
results = cursor.fetchall()
finally:
conn.commit()
user = Voter(results[0][0], results[0][1])
conn.close()
return user
def register(request, unique_id=None):
request.session['django_language'] = 'el'
establishment = None
voter = None
if unique_id:
establishment = get_object_or_404(Establishment,
unique_id=unique_id)
if establishment.voter_id:
voter = establishment.voter
else:
voter = Voter()
if request.method == 'POST':
if unique_id:
form = RegistrationForm(request.POST, instance=establishment)
else:
form = RegistrationForm(request.POST)
if form.is_valid():
voter.first_name = form.cleaned_data['voter_first_name']
voter.surname = form.cleaned_data['voter_surname']
voter.email = form.cleaned_data['voter_email']
voter.mobile_phone = form.cleaned_data['voter_mobile_phone']
voter.save()
# is_valid changes the instance. Invalidate, in order to avoid
# storing those changes.
establishment = Establishment.objects.get(unique_id=unique_id)
establishment.voter = voter
establishment.save()
return render(request, 'roll/thanks.html', {
'voter_first_name': voter.first_name,
'voter_surname': voter.surname,
'voter_email': voter.email,
'voter_mobile_phone': voter.mobile_phone,
'registration_url': request.path
})
else:
if unique_id:
form = RegistrationForm(
instance=establishment,
initial={
'voter_first_name': voter.first_name,
'voter_surname': voter.surname,
'voter_email': voter.email,
'voter_mobile_phone': voter.mobile_phone,
})
else:
form = RegistrationForm()
return render(request, 'roll/registration.html', {
'form': form,
'voter': voter,
'form_action': request.path,
})
def get_voter(request, user, election):
"""
return the current voter
"""
voter = None
if request.session.has_key('CURRENT_VOTER_ID'):
voter = Voter.objects.get(id=request.session['CURRENT_VOTER_ID'])
if voter.election != election:
voter = None
if not voter:
if user:
voter = Voter.get_by_election_and_user(election, user)
return voter
def register(request, unique_id=None):
establishment = None
voter = None
if unique_id:
establishment = Establishment.objects.get(unique_id=unique_id)
if establishment.voter_id:
voter = establishment.voter
else:
voter = Voter()
if request.method == 'POST':
if unique_id:
form = RegistrationForm(request.POST, instance=establishment)
else:
form = RegistrationForm(request.POST)
if form.is_valid():
voter.name = form.cleaned_data['voter_name']
voter.email = form.cleaned_data['voter_email']
voter.mobile_phone = form.cleaned_data['voter_mobile_phone']
voter.save()
# is_valid changes the instance. Invalidate, in order to avoid
# storing those changes.
establishment = Establishment.objects.get(unique_id=unique_id)
establishment.voter = voter
establishment.save()
return render(
request, 'roll/thanks.html', {
'voter_name': voter.name,
'voter_email': voter.email,
'voter_mobile_phone': voter.mobile_phone,
'registration_url': request.path
})
else:
if unique_id:
form = RegistrationForm(instance=establishment,
initial={
'voter_name': voter.name,
'voter_email': voter.email,
'voter_mobile_phone':
voter.mobile_phone,
})
else:
form = RegistrationForm()
return render(request, 'roll/registration.html', {
'form': form,
'voter': voter,
'form_action': request.path,
})
def return_vote_hmac(data):
'''
In three steps auth methods (id-num, id-photo), return directly the hmac
to vote as there's no third-step verification.
'''
from crypto import salted_hmac, get_random_string
from app import db
from models import Voter
from crypto import hash_str
dni = data["dni"].upper()
ip_addr = data['ip_addr']
curr_eid = current_app.config.get("CURRENT_ELECTION_ID", 0)
# create voter
voter = Voter(
election_id=curr_eid,
ip=ip_addr,
first_name=data['first_name'],
last_name=data['last_name'],
email="-",
tlf="-",
postal_code=data.get("postal_code", ""),
receive_mail_updates=data["receive_updates"],
lang_code=current_app.config.get("BABEL_DEFAULT_LOCALE", "en"),
status=Voter.STATUS_AUTHENTICATED,
modified=datetime.utcnow(),
message=None,
is_active=True,
dni=hash_str(dni),
)
db.session.add(voter)
db.session.commit()
data['identifier'] = voter.id
message = "%d#%d" % (int(datetime.utcnow().timestamp()), voter.id)
key = current_app.config.get("AGORA_SHARED_SECRET_KEY", "")
ret_data = dict(message=message,
sha1_hmac=salted_hmac(key, message, "").hexdigest())
return make_response(json.dumps(ret_data), 200)
def add_voter():
body = request.json
no_ktp = body['no_ktp']
nama = body['nama']
password = body['password']
alamat = body['alamat']
try:
voter = Voter(no_ktp=no_ktp,
nama=nama,
password=password,
alamat=alamat)
db.session.add(voter)
db.session.commit()
return "Voter added. user id={}".format(voter.no_ktp), 200
except Exception as e:
return (str(e)), 400
def getPoll():
p = request.args.get("pid")
# get by pid
try:
poll = db_session.query(Poll).filter_by(pid=p).first()
# create voter
voter = Voter(poll.id, poll.x, poll.y)
db_session.add(voter)
db_session.flush()
db_session.commit()
resp = jsonify(
data={
"question":
poll.question,
"options":
poll.options.split("|"),
"x":
voter.x,
"y":
voter.y,
"vid":
voter.id,
"viewers":
poll.viewers,
"winners":
poll.winners.split("|"),
"status":
"COMPLETED" if poll.completed else (
"STARTED" if poll.started else "WAITING")
})
resp.headers['Access-Control-Allow-Origin'] = '*'
return resp, 200
except Exception as e:
print(e)
return "This poll does not seem to exist.", 400
def register_request(data):
'''
register the request in the Voter database with STATUS_REQUESTED
You can move this pipe before or after check_*_blacklisted in the pipeline,
depending on if you get too many blacklisted requests to avoid too many
writes on the database
'''
from app import db
from models import Voter
ip_addr = data['ip_addr']
# disable older registration attempts for this tlf
curr_eid = current_app.config.get("CURRENT_ELECTION_ID", 0)
# create voter and send sms
voter = Voter(
election_id=curr_eid,
ip=ip_addr,
first_name=data["first_name"],
last_name=data["last_name"],
email=data.get("email", ""),
tlf=data.get("tlf", ""),
postal_code=data.get("postal_code", ""),
receive_mail_updates=data["receive_updates"],
lang_code=current_app.config.get("BABEL_DEFAULT_LOCALE", "en"),
status=Voter.STATUS_REQUESTED,
message=None,
is_active=True,
dni=data["dni"].upper(),
)
db.session.add(voter)
db.session.commit()
data['requested_voter'] = voter
return RET_PIPE_CONTINUE
def validate(self):
user = users.get_current_user()
self.logout = users.create_logout_url(self.request.uri)
self.voter = Voter.gql('WHERE user = :1', user).get()
if not self.voter:
return 'invalid'
self.years = Poll.openYears()
if not self.years:
return 'closed'
defaultYear = max(self.years)
self.year = int(self.request.get('year') or self.voter.year
or defaultYear)
if self.year not in self.years:
self.year = defaultYear
if self.voter.year != self.year:
self.voter.year = self.year
self.voter.put()
self.ballot = Ballot.gql('WHERE voter = :1 and year = :2',
self.voter, self.year).get()
return None
def user_can_see_election(request, election):
user = get_user(request)
if not election.private_p:
return True
# election is private
# but maybe this user is the administrator?
if user_can_admin_election(user, election):
return True
# or maybe this is a trustee of the election?
trustee = get_logged_in_trustee(request)
if trustee and trustee.election.uuid == election.uuid:
return True
voter = get_voter(request, user, election)
if user and not voter:
if user.user_type in settings.AUTH_BIND_USERID_TO_VOTERID:
voter = Voter.get_by_election_and_voter_id(election, user.user_id)
# then this user has to be a voter
return (voter != None)
def voters_by_precinct(precinct):
voters = Voter.select().where(registeredprecinct=precinct)
context = {"precinct": precinct}
context.update(paginate(voters))
return render_template("voter_list.precinct.html", **context)
def search():
search_form = Search(request.args)
voters = Voter.search(search_form.query.data, search_form.type.data)
context = {"form": search_form}
context.update(paginate(voters))
return render_template("voter_list.search.html", **context)
def voter_detail(voterid):
try:
voter = Voter.get(id=voterid)
except Voter.DoesNotExist:
voter = None
return render_template("voter_detail.html", voter=voter)
def create_voter():
for entry in request.json['voters']:
voter_id = entry['VOTERID']
last_name = entry['LAST-NAME']
first_name = entry['FIRST-NAME']
mid_init = entry["MID-INIT"]
suffix = entry['SUFFIX']
date_of_birth = entry["DATE-OF-BIRTH"]
birth_year = entry["BIRTH YEAR"]
phone = entry["PHONE"]
address = entry["ADDR"]
home_no = entry["HOME-NO"]
home_apt = entry["HOME-APT"]
home_street = entry["HOME-STREET"]
home_dev = entry["HOME-DEV"]
home_city = entry["HOME-CITY"]
home_zipcode = entry["HOME-ZIPCODE"]
county = entry["COUNTY"]
ed = entry["ED"]
rd = entry["RD"]
sd = entry["SD"]
cn_levy = entry["CNLEVY"]
wilm = entry["WILM"]
code_home_city = entry["CODE-HOME-CITY"]
sch_dist = entry["SCH-DIST"]
party = entry["PARTY"]
date_reg = entry["DATE-REG"]
pp_hist_1 = entry["PP-HIST-1"]
pp_hist_2 = entry["PP-HIST-2"]
pr_hist_1 = entry["PR-HIST-1"]
pr_hist_2 = entry["PR-HIST-2"]
pr_hist_3 = entry["PR-HIST-3"]
gen_hist_1 = entry["GEN-HIST-1"]
gen_hist_2 = entry["GEN-HIST-2"]
gen_hist_3 = entry["GEN-HIST-3"]
gen_hist_4 = entry["GEN-HIST-4"]
gen_hist_5 = entry["GEN-HIST-5"]
sp_hist_1 = entry["SP-HIST-1"]
sp_hist_2 = entry["SP-HIST-2"]
sp_hist_3 = entry["SP-HIST-3"]
schl_hist_1 = entry["SCHL-HIST-1"]
schl_hist_2 = entry["SCHL-HIST-2"]
schl_hist_3 = entry["SCHL-HIST-3"]
schl_hist_4 = entry["SCHL-HIST-4"]
schl_hist_5 = entry["SCHL-HIST-5"]
ref_hist_1 = entry["REF-HIST-1"]
ref_hist_2 = entry["REF-HIST-2"]
ref_hist_3 = entry["REF-HIST-3"]
ref_hist_4 = entry["REF-HIST-4"]
ref_hist_5 = entry["REF-HIST-5"]
mail_no = entry["MAIL-NO"]
mail_apt = entry["MAIL-APT"]
mail_street = entry["MAIL-STR"]
mail_city = entry["MAIL-CITY"]
mail_state = entry["MAIL-STATE"]
mail_zip = entry["MAIL-ZIP"]
date_last_chg = entry["DATE-LAST-CHG"]
code_change = entry["CODE-CHANGE"]
status = entry["STATUS"]
gender = entry["GENDER"]
new_voter = Voter(
voter_id, last_name, first_name, mid_init, suffix, date_of_birth,
birth_year, phone, address, home_no, home_apt, home_street,
home_dev, home_city, home_zipcode, county, ed, rd, sd, cn_levy,
wilm, code_home_city, sch_dist, party, date_reg, pp_hist_1,
pp_hist_2, pr_hist_1, pr_hist_2, pr_hist_3, gen_hist_1, gen_hist_2,
gen_hist_3, gen_hist_4, gen_hist_5, sp_hist_1, sp_hist_2,
sp_hist_3, schl_hist_1, schl_hist_2, schl_hist_3, schl_hist_4,
schl_hist_5, ref_hist_1, ref_hist_2, ref_hist_3, ref_hist_4,
ref_hist_5, mail_no, mail_apt, mail_street, mail_city, mail_state,
mail_zip, date_last_chg, code_change, status, gender)
db.session.add(new_voter)
db.session.commit()
return voter_schema.jsonify(new_voter)
ref_hist_1 = entry["REF-HIST-1"]
ref_hist_2 = entry["REF-HIST-2"]
ref_hist_3 = entry["REF-HIST-3"]
ref_hist_4 = entry["REF-HIST-4"]
ref_hist_5 = entry["REF-HIST-5"]
mail_no = entry["MAIL-NO"]
mail_apt = entry["MAIL-APT"]
mail_street = entry["MAIL-STR"]
mail_city = entry["MAIL-CITY"]
mail_state = entry["MAIL-STATE"]
mail_zip = entry["MAIL-ZIP"]
date_last_chg = entry["DATE-LAST-CHG"]
code_change = entry["CODE-CHANGE"]
status = entry["STATUS"]
gender = entry["GENDER"]
new_voter = Voter(
voter_id, last_name, first_name, mid_init, suffix, date_of_birth,
birth_year, phone, address, home_no, home_apt, home_street,
home_dev, home_city, home_zipcode, county, ed, rd, sd, cn_levy,
wilm, code_home_city, sch_dist, party, date_reg, pp_hist_1,
pp_hist_2, pr_hist_1, pr_hist_2, pr_hist_3, gen_hist_1, gen_hist_2,
gen_hist_3, gen_hist_4, gen_hist_5, sp_hist_1, sp_hist_2,
sp_hist_3, schl_hist_1, schl_hist_2, schl_hist_3, schl_hist_4,
schl_hist_5, ref_hist_1, ref_hist_2, ref_hist_3, ref_hist_4,
ref_hist_5, mail_no, mail_apt, mail_street, mail_city, mail_state,
mail_zip, date_last_chg, code_change, status, gender)
db.session.add(new_voter)
db.session.commit()
import pandas as pd
from models import Voter, Candidate
candidates = [Candidate() for _ in range(2)]
voters = [Voter().to_dict() for idx in range(10000)]
# voter_df = pd.DataFrame.from_dict(voters, orient='index', columns=["left_right"])
# voter_df = pd.DataFrame(columns=Voter.__slots__)
voter_df = pd.DataFrame(voters)
voter_df['vote'] = voter_df['left_right'].apply(Voter.vote, args=[candidates])
winner = voter_df['vote'].mode().iloc[0]
mean = voter_df['left_right'].mean()
mean_winner = Voter.vote(mean, candidates)
median = voter_df['left_right'].median()
median_winner = Voter.vote(median, candidates)
assert winner == mean_winner == median_winner
print("done")
def get(self, id):
voter = Voter.get_by_id(int(id))
if not voter:
self.response.out.write('No such voter: ' + id)
return
self.render('voter.html', voter=voter)
