def zkp_check():
#check if voter has valid voter id
voter = Voter.query.filter_by(voter_id=request.json["voter_id"]).first()
tvote = TVote.query.filter_by(voter=request.json["voter_id"]).first()
if tvote == None:
return "error"
c = [int(getattr(tvote, "vote%d" % i))
for i in range(NUM_CANDIDATES)] #stored in db
u = [int(getattr(tvote, "u%d" % i))
for i in range(NUM_CANDIDATES)] #stored in db
e = [getattr(tvote, "e%d" % i) for i in range(NUM_CANDIDATES)]
v = [int(x) for x in request.json["v"]] #array of v
w = [int(x) for x in request.json["w"]] #array of w
#do check
check_pass = True
for i in range(NUM_CANDIDATES):
a = (pow(pub.g, v[i], pub.n_sq) * pow(c[i], e[i], pub.n_sq) *
pow(w[i], pub.n, pub.n_sq)) % pub.n_sq
b = u[i]
if a == b:
continue
else:
check_pass = False
#break
if check_pass:
if not tvote.failed:
tvote.correct = tvote.correct + 1
if tvote.correct == ZKP_ITERATIONS:
vote = Vote.query.filter_by(
voter=request.json["voter_id"]).first()
if vote == None:
vo = Vote()
vo.voter = tvote.voter
for i in range(
NUM_CANDIDATES): #assign vote values to vote entry
setattr(vo, "vote%d" % i, str(c[i]))
db_session.add(vo)
db_session.commit()
else:
tvote.failed = True
db_session.commit()
return "error"
return "ok"
def api_record_vote():
token = session['token']
user = User.query.filter_by(token=token).first()
if user.vote.first():
return abort(403)
choices = request.args.get('choices')
choices_list = choices.split(',')
choices_list = choices_list[:len(choices_list) - 1] # remove the last item
if len(choices_list) > app.config['MAX_CHOICES']:
return abort(403)
vote = Vote(owner=user.id)
options_list = []
for choice in choices_list:
options_list.append(Option.query.filter_by(id=choice).first())
vote.votes = options_list
db.session.add(vote)
db.session.commit()
return jsonify(status="OK")
def vote(request, id_num):
vf = VoteForm(request.POST or None)
post = get_object_or_404(Post, pk=id_num)
if vf.is_valid() and request.user.is_authenticated():
user = request.user
prev_vote = Vote.objects.filter(
user=user,
parent_post=post.parent,
)
if prev_vote.exists():
prev_vote.delete()
messages.warning(
request,
'Changing your vote because you already voted on some child of the parent post'
)
vote = Vote(post=post, parent_post=post.parent, user=user)
vote.save()
return HttpResponseRedirect(request.META["HTTP_REFERER"])
def get(self, post_id):
session = get_current_session()
if session.has_key('user'):
user = session['user']
try:
post = db.get(post_id)
if not post.already_voted():
vote = Vote(user=user, post=post, target_user=post.user)
vote.put()
post.remove_from_memcache()
post.user.remove_from_memcache()
self.response.out.write('Ok')
else:
self.response.out.write('No')
except db.BadValueError:
self.response.out.write('Bad')
else:
self.response.out.write('Bad')
def vote(event_id):
access_token = get_token(url_for('vote', event_id=event_id))
if not access_token:
return auth_redirect(url_for('vote', event_id=event_id))
if 'code' in request.args:
return redirect(url_for('vote', event_id=event_id))
event = Event.query.filter_by(id=event_id).first()
available = json.loads(event.available)
me = fb_call('me', args={'access_token': access_token})
if request.method == 'POST':
vote = Vote(me['id'], me['name'], event_id, request.form['fb-times'])
db.session.add(vote)
db.session.commit()
return redirect(url_for('vote', event_id=event_id))
#events = fb_call('me/events',
# args={'access_token': access_token})
votes = Vote.query.filter_by(event=event_id).all()
users = [(vote.user_id, vote.user_name) for vote in votes]
votejson = [json.loads(vote.vote) for vote in votes]
results, usersbytime, top = aggregate_votes(votejson, users)
used_times = [False] * 24
for i in xrange(24):
for l in available:
if i in l:
used_times[i] = True
return render_template(
'schedule.html',
title='Schedule an event',
#events=events['data'],
event_id=event_id,
days=days(),
times=times,
used_times=used_times,
available=available,
usersbytime=usersbytime,
users=users,
results=results,
top=top or 1)
def post_new_quote():
body = request.get_json()
conditions = {}
if "conditions" in body:
conditions = body['conditions']
ip = request.environ.get('HTTP_X_FORWARDED_FOR', request.remote_addr)
ip = ip.partition(',')[0]
quote = Quote(text=body['text'], conditions=json.dumps(conditions), view_count=1, ip=ip, active=False)
db.session.add(quote)
db.session.commit()
vote = Vote(ip=ip, value=1, quote_id=quote.id) # auto upvote every new quote by 1
db.session.add(vote)
db.session.commit()
return jsonify(quote.serialize)
def vote_handler(self, call: telebot.types.CallbackQuery):
telegram_id = call.from_user.id
chat_id = str(call.message.chat.id)
msg_id = call.message.message_id
mark = int(call.data)
username = '******' + call.from_user.username if call.from_user.username else call.from_user.first_name
user = User.get(chat_id, telegram_id)
if not user:
user = User(telegram_id, chat_id, username).save()
meme = Meme.get_meme(chat_id, msg_id - 1)
if meme and not Vote.is_voted(user.id, meme.id):
Vote(user.id, meme.id, mark).save()
print(user.username, 'voted', mark, flush=True)
self.answer_callback_query(call.id, text='You voted')
else:
print(user.username, 'have tried to vote again', flush=True)
self.answer_callback_query(call.id, text='You have already voted')
def post():
values = {}
vote_value = request.form['vote']
vote = Vote()
for item in request.form.getlist('value[]'):
if vote.get_vote_title(item) is not None:
values[item] = vote.get_vote_title(item)
elif int(item) == Vote.CUSTOM_VOTE_ID and vote_value:
values[item] = vote_value
if values:
# add vote
vote.ip = request.remote_addr
vote.votes = values
try:
vote_current = Vote.objects(
ip=request.remote_addr,
created_at__gte=(datetime.datetime.now() -
datetime.timedelta(minutes=15)))
if vote_current:
raise ValueError("You've already voted!")
vote.save()
suffix = VoteView.ordinal(len(Vote.objects))
return jsonify({
'status':
'ok',
'message':
'Thank your for voting! You are the %s fan of python' %
suffix
})
except ValueError as e:
return jsonify({'status': 'error', 'message': e.message})
except Exception:
return jsonify({
'status': 'error',
'message': 'Error while saving vote. Sorry :('
})
else:
return jsonify({
'status': 'error',
'message': 'Choose any option to vote'
})
def post(self, post_id):
session = get_current_session()
if session.has_key('user'):
message = sanitizeHtml(self.request.get('message'))
user = session['user']
if len(message) > 0:
try:
post = db.get(post_id)
post.remove_from_memcache()
comment = Comment(message=message, user=user, post=post)
comment.put()
vote = Vote(user=user, comment=comment, target_user=user)
vote.put()
self.redirect('/noticia/' + post_id)
except db.BadKeyError:
self.redirect('/')
else:
self.redirect('/noticia/' + post_id)
else:
self.redirect('/login')
def at_least_one_vote_per_item(self):
# make sure each item has 1 vote
items = Item.query()
for it in items:
vote = it.votes.filter("voter =", it.owner).get()
if not vote:
vote = Vote()
vote.item = it
vote.vote = VoteValue.VOTE_LIKED
vote.voter = it.owner
vote.comment = "blah"
it.upVotes = 1
vote.put()
it.save()
if it.votesUp == it.votesDown == 0:
if vote.vote == VoteValue.VOTE_LIKED:
it.votesUp = 1
elif vote.vote == VoteValue.VOTE_DISLIKED:
it.votesDown = -1
it.save()
def cast_vote(person_id, movie_id):
"""
Submit a vote, one user to one movie. Return whether the vote was cast.
"""
# this query returns None if no rows are returned
exists = DBSession.query(Vote).filter_by(person_id=person_id, movie_id=movie_id).first()
if exists:
result = {
"result": "ERROR",
"message": "Person has already voted for this movie."
}
# HTTP status code 409 means "conflict"
return json.dumps(result), 409
else:
# create a new Vote and save it to the database
vote = Vote(person_id=person_id, movie_id=movie_id)
DBSession.add(vote)
DBSession.commit()
result = {"result": "OK", "message": "Vote registered."}
return json.dumps(result)
def post(self,comment_id):
session = get_current_session()
if session.has_key('user'):
message = helper.sanitizeHtml(self.request.get('message'))
user = session['user']
if len(message) > 0:
try:
parentComment = db.get(comment_id)
comment = Comment(message=message,user=user,post=parentComment.post, father=parentComment)
comment.put()
comment.post.remove_from_memcache()
vote = Vote(user=user, comment=comment, target_user=user)
vote.put()
Notification.create_notification_for_comment_and_user(comment,parentComment.user)
self.redirect('/noticia/' + str(parentComment.post.key()))
except db.BadKeyError:
self.redirect('/')
else:
self.redirect('/responder/' + comment_id)
else:
self.redirect('/login')
def get(self, comment_id):
session = get_current_session()
if session.has_key('user'):
user = session['user']
try:
comment = db.get(comment_id)
if not comment.already_voted():
vote = Vote(user=user,
comment=comment,
target_user=comment.user)
vote.put()
helper.killmetrics("Vote", "Comment", "do", session, "",
self)
comment.remove_from_memcache()
comment.user.remove_from_memcache()
self.response.out.write('Ok')
else:
self.response.out.write('No')
except db.BadValueError:
self.response.out.write('Bad')
else:
self.response.out.write('Bad')
def voting(request, poll_id):
poll = Poll.objects.get(id=poll_id)
books = Book.objects.filter(poll=poll_id)
already_voted = Vote.objects.filter(user=request.user).filter(poll=poll)
for book in books:
number_of_votes = Vote.objects.filter(book=book)
book.votes = len(number_of_votes)
books = sorted(books, key=operator.attrgetter('votes'), reverse=True)
if len(already_voted) >= 3:
disabled = 'disabled="disabled"'
else:
disabled = ''
context = RequestContext(
request, {
'poll': poll,
'books': books,
'disabled': disabled,
'already_voted': len(already_voted),
})
if request.method == "POST":
for book in books:
votes = request.REQUEST[str(book.id)]
if votes:
i = int(votes)
while i > 0:
vote = Vote(user=request.user, poll=poll, book=book)
vote.save()
i -= 1
# return HttpResponse(i)
else:
continue
return redirect('/polls/voting/' + str(poll_id))
return render(request, 'polls/voting.html', context)
def vote(request, id):
this_topic = Topic.objects.get(pk=id)
is_voted = False
try:
vote_thistopic = this_topic.votes.get(user=request.user.get_profile())
is_voted = True
except:
pass
if is_voted == False:
this_vote = Vote(user=request.user.get_profile())
#this_topic.votes.add(user = request.user)
topic_type = ContentType.objects.get_for_model(Topic)
this_vote.content_type = topic_type
this_vote.object_id = this_topic.id
this_vote.save()
#update vote count
this_topic.save()
return HttpResponseRedirect(reverse(topic, args=[this_topic.id]))
def insert_to_vote_db_table(event, context):
"""
Example message from Lambda HTTP API:
{
"poll": 1
"answer": "cat"
"date": "2020-07-23 04:19:26.819419"
}
"""
for message in event["Records"]:
logger.info(message)
body = json.loads(message["body"])
vote = Vote(
id=f"vote_{uuid.uuid4()}",
date=datetime.fromisoformat(body["date"]),
poll=body["poll"],
answer=body["answer"],
)
response = db.insert_vote(vote)
logger.info(f"inserted vote {vote.id} to dynamodb")
def post(self):
it_id = int(self.request.get('item_id'))
it = Item.get_by_id(it_id)
voteScore = int(self.request.get("vote"))
voteUntried = bool(self.request.get("untried"))
my_votes = Vote.query(Vote.voter == self.user_id, Vote.item == it.key)
if my_votes.count() == 0:
# a new vote
new_vote = Vote()
new_vote.item = it
new_vote.voter = self.user_id
else:
# roll back the old vote
new_vote = my_votes.get()
oldVote, oldUntried = new_vote.stars, new_vote.untried
new_vote.stars = voteScore
new_vote.untried = voteUntried
new_vote.comment = self.request.get("comment")
new_vote.when = datetime.datetime.now()
new_vote.put()
it.save()
# refresh cache
self.response.out.write('OK')
def user_vote():
if 'user' not in session or 'team' not in session:
return jsonify(status='Error', error='User is not logged in')
req = request.json
value = req.get('value')
if value is None:
return make_response(
jsonify(status='Error', error='Missing value field in request'),
401)
try:
db.session.add(
Vote(user=session['user'], team=session['team'], value=value))
db.session.commit()
except Exception as e:
return make_response(
jsonify(
status='Error',
error=
'You cannot vote twice in the same round, wait for the next question'
), 401)
return jsonify(status='OK')
def index(request):
sujets = Sujet.objects
#sujets = sujets.filter(vote__date__lt=datetime.now())
sujets = sujets.order_by('nom')
sujets = sujets.all()
poids = Poids.objects
poids = poids.order_by('ordre')
poids = poids.all()
render_params = {}
render_params['sujets'] = sujets
render_params['l_poids'] = poids
if request.method == "POST":
votes_in = (entry for entry in request.POST.items()
if entry[0].isdigit())
for poids_id, sujet_id in votes_in:
sujet = Sujet.objects.get(id=sujet_id)
poids = Poids.objects.get(id=poids_id)
vote = Vote(nom="Jacques", sujet=sujet, poids=poids)
vote.save()
return render(request, 'vote/index.html', render_params)
def vote(recipe_id):
form = VoteForm(request.form)
if request.method == 'POST' and form.validate():
vote = Vote.query.filter_by(recipe_id=recipe_id,
user_id=current_user.id).first()
if vote:
vote.value = int(request.form['value'])
else:
vote = Vote(value=int(request.form['value']),
user_id=current_user.id,
recipe_id=recipe_id)
db.session.add(vote)
db.session.commit()
recipe = Recipe.query.filter_by(id=recipe_id).first()
recipe.calculate_average()
db.session.add(recipe)
db.session.commit()
flash('Vote added successfully', 'success')
return redirect(url_for('show_recipe', recipe_id=recipe_id))
flash('Error: You can\'t give an empty or out of range vote', 'danger')
return redirect(url_for('show_recipe', recipe_id=recipe_id))
def _make_vote(id, uid, name):
movie = _fetch_movie(id)
if movie:
q = db.Query(Vote)
q.filter('service_id =', id)
q.filter('facebook_uid =', uid)
existing_vote = q.get()
if existing_vote:
return False
movie.votes = movie.votes + 1
movie.put()
thevote = Vote(service_id=id, facebook_uid=uid, facebook_name=name)
thevote.save()
return True
return False
def vote():
if request.method == 'GET':
return render_template('vote.html')
else:
user_id = session.get('user_id')
title = request.form.get('title')
option1 = request.form.get('option1')
option1 = "A. " + option1
option2 = request.form.get('option2')
option2 = "B. " + option2
option3 = request.form.get('option3')
option3 = "C. " + option3
option4 = request.form.get('option4')
option4 = "D. " + option4
if option3 == 'None' and option4 == 'None': #若只有两个选项
vote = Vote(title=title,
founder_id=user_id,
sum_options=0,
option1=option1,
sum_option1=0,
option2=option2,
sum_option2=0,
option3=option3,
sum_option3=-1,
option4=option4,
sum_option4=-1)
elif option3 == 'None' and option4 != 'None': #若只有三个选项
vote = Vote(title=title,
founder_id=user_id,
sum_options=0,
option1=option1,
sum_option1=0,
option2=option2,
sum_option2=0,
option3=option4,
sum_option3=0,
option4=option3,
sum_option4=-1)
elif option3 != 'None' and option4 == 'None': #若只有三个选项
vote = Vote(title=title,
founder_id=user_id,
sum_options=0,
option1=option1,
sum_option1=0,
option2=option2,
sum_option2=0,
option3=option3,
sum_option3=0,
option4=option4,
sum_option4=-1)
else: #若有四个选项
vote = Vote(title=title,
founder_id=user_id,
sum_options=0,
option1=option1,
sum_option1=0,
option2=option2,
sum_option2=0,
option3=option3,
sum_option3=0,
option4=option4,
sum_option4=0)
db.session.add(vote)
db.session.commit()
return redirect(url_for('vote_detail', vote_id=vote.id))
def submitballot():
poll = open_polls().first()
if not poll:
flash('No open polls', 'info')
return redirect(url_for('index'))
ballot = Ballot.query.filter_by(poll_id=poll.id).filter_by(
user_id=g.user.id).first()
teams = Team.query.all()
voter = current_user.is_voter
editing = bool(ballot)
closes_eastern = poll.closeTime.replace(tzinfo=utc).astimezone(eastern_tz)
if ballot:
vote_dicts = [{} for i in range(25)]
for vote in ballot.votes:
vote_index = vote.rank - 1
vote_dicts[vote_index]['team'] = Team.query.get(vote.team_id)
vote_dicts[vote_index]['reason'] = vote.reason
data_in = {'votes': vote_dicts}
form = PollBallotForm(data=data_in)
elif app.config['DEBUG']:
vote_dicts = [{} for i in range(25)]
for i in range(25):
vote_dicts[i]['team'] = Team.query.get(i * 4 + 1)
vote_dicts[i]['reason'] = Team.query.get(i * 4 + 1).full_name
data_in = {'votes': vote_dicts}
form = PollBallotForm(data=data_in)
else:
form = PollBallotForm()
if form.validate_on_submit():
if ballot:
for vote in ballot.votes:
db.session.delete(vote)
ballot.updated = datetime.utcnow()
else:
ballot = Ballot(updated=datetime.utcnow(),
poll_id=poll.id,
user_id=g.user.id)
db.session.add(ballot)
# must commit here to get ballot id for the Vote objects.
#
# there is a race condition here with the check to see if a ballot exists earlier in this function.
# the database maintains the invariant of one ballot per (user, poll) pair, so this commit may fail.
# if it does, it's probably alright, as it means we came here with no ballot existing, but now one exists.
# so send them to their most recent ballot.
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
ballot = Ballot.query.filter_by(poll_id=poll.id).filter_by(
user_id=g.user.id).first()
if ballot:
return redirect(url_for('ballot', ballot_id=ballot.id))
else:
flash('Something went wrong... check your ballot.', 'warning')
return redirect(url_for('index'))
for voteRank, vote in enumerate(form.votes):
voteModel = Vote(ballot_id=ballot.id,
team_id=vote.team.data.id,
rank=(voteRank + 1),
reason=vote.reason.data)
db.session.add(voteModel)
db.session.commit()
flash('Ballot submitted.', 'success')
return redirect(url_for('ballot', ballot_id=ballot.id))
return render_template('submitballot.html',
teams=teams,
form=form,
poll=poll,
title='Submit Ballot',
is_provisional=not voter,
editing=editing,
closes_eastern=closes_eastern)
def record_vote():
current_uuid = get_uuid_from_cookie(request.cookies)
current_score = get_current_user_score(request.cookies)
user_choice = int(request.args.get('choice'))
[image_1, image_2] = get_current_images(request.cookies)
print image_1
print image_2
if image_1.score > image_2.score:
correct_answer = 1
elif image_2.score > image_1.score:
correct_answer = 2
else:
correct_answer = 0
if current_score['num_correct'] is None:
current_score['num_correct'] = 0
if current_score['num_wrong'] is None:
current_score['num_wrong'] = 0
if user_choice == correct_answer:
user_correct = 1
current_score['num_correct'] = current_score['num_correct'] + 1
else:
user_correct = 0
current_score['num_wrong'] = current_score['num_wrong'] + 1
# update_current_score(current_uuid, current_score)
new_vote = Vote(current_uuid, image_1.reddit_id, image_2.reddit_id,
user_choice, correct_answer)
db.session.add(new_vote)
db.session.commit()
if image_1:
image_1_score = image_1.score
else:
image_1_score = 0
if image_2:
image_2_score = image_2.score
else:
image_2_score = 0
percent_correct = format_correct_percentage(current_score)
num_remaining = current_score['num_questions'] - (
current_score['num_correct'] + current_score['num_wrong'])
ret_vals = {
'status': 'OK',
'image_1_karma': image_1_score,
'image_2_karma': image_2_score,
'correct': user_correct,
'num_correct': current_score['num_correct'],
'num_wrong': current_score['num_wrong'],
'num_remaining': num_remaining,
'user_choice': user_choice
}
# print current_score.num_correct + current_score.num_wrong
if current_score['num_correct'] + current_score[
'num_wrong'] >= current_score['num_questions']:
ret_vals['end_of_game'] = 1
# print 'DUMPS'
# print json.dumps(ret_vals)
# print 'JSONIFY'
# print jsonify(ret_vals)
response = jsonify(ret_vals)
response.set_cookie('num_wrong', str(current_score['num_wrong']))
response.set_cookie('num_correct', str(current_score['num_correct']))
response.set_cookie('num_seen', str(current_score['num_seen'] + 1))
return response
def post(self):
session = get_current_session()
url = self.request.get('url')
title = helper.sanitizeHtml(self.request.get('title'))
message = helper.sanitizeHtml(self.request.get('message'))
nice_url = helper.sluglify(title)
if session.has_key('user'):
if len(nice_url) > 0:
user = session['user']
if len(message) == 0: #is it a post or a message?
#Check that we don't have the same URL within the last 'check_days'
since_date = date.today() - timedelta(days=7)
q = Post.all().filter("created >",
since_date).filter("url =",
url).count()
url_exists = q > 0
q = Post.all().filter("nice_url", nice_url).count()
nice_url_exist = q > 0
try:
if not url_exists:
if not nice_url_exist:
post = Post(url=url,
title=title,
message=message,
user=user,
nice_url=nice_url)
post.put()
vote = Vote(user=user,
post=post,
target_user=post.user)
vote.put()
Post.remove_cached_count_from_memcache()
self.redirect('/noticia/' + str(post.nice_url))
else:
session[
'post_error'] = "Este titulo ha sido usado en una noticia anterior"
self.redirect('/agregar')
else:
session[
'post_error'] = "Este link ha sido entregado en los ultimo 7 dias"
self.redirect('/agregar')
except db.BadValueError:
session[
'post_error'] = "El formato del link no es valido"
self.redirect('/agregar')
else:
q = Post.all().filter("nice_url", nice_url).count()
nice_url_exist = q > 0
if not nice_url_exist:
post = Post(title=title,
message=message,
user=user,
nice_url=nice_url)
post.put()
post.url = helper.base_url(
self) + "/noticia/" + post.nice_url
post.put()
Post.remove_cached_count_from_memcache()
vote = Vote(user=user,
post=post,
target_user=post.user)
vote.put()
self.redirect('/noticia/' + post.nice_url)
else:
session[
'post_error'] = "Este titulo ha sido usado en una noticia anterior"
self.redirect('/agregar')
else:
session['post_error'] = "Necesitas agregar un titulo"
self.redirect('/agregar')
else:
self.redirect('/login')
async def post(self):
req_vote = self.get_dict_from_json()
v = Vote(req_vote).mongo_encode()
inserted_vote = await self._db.votes.insert_one(v)
v['_id'] = str(inserted_vote.inserted_id)
self.write({'success': True, 'vote': v})
class CreateVoteActivity(CreateView): queryset = Vote() template_name='vote_test.html' form_class = VoteForm success_url = '/'
j1y4ulsr0qiqhuopn0pb.png
oadm6fjdul81nm4mdyti.png
cjk72cu2llth2xpag75n.png
tzvvtnix8bsivvi0kbxw.png""".split("\n")
genders = ["male", "female"]
ss = []
for i in range(10):
name = random.choice(names)
picture_url = random.choice(pictures)
gender = random.choice(genders)
s = Student(name=name,
picture_url=picture_url,
gender=gender,
klass_id=k.id)
db.session.add(s)
ss.append(s)
db.session.commit()
for s in ss:
for i in range(10):
pubdate = datetime.utcnow() - timedelta(days=i)
v = Vote(student_id=s.id,
klass_id=k.id,
pub_date=pubdate,
choice=random.choice([1, 2, 3, 4, 5]))
db.session.add(v)
db.session.commit()
def validate(self, data):
vote = Vote(**data)
vote.clean()
return data
def vote(cls, student_id, class_id, choice):
v = Vote(klass_id=class_id, choice=choice, student_id=student_id)
db.session.add(v)
db.session.commit()
return v
