def registerVote(plainText, username, password): """Register plainText as the vote of user with given username and password""" if GlobalVariables.objects.filter(varname='electionState')[0].value != 'election': return False userlist = Users.objects.filter(username=username) #print len(userlist) if (len(userlist) == 0): return False assert(len(userlist) == 1) decryptedPrivateKey = cryptography.symmetricDecrypt(userlist[0].encryptedPrivateKey,password) certificate = cryptography.asymmetricSign(plainText,decryptedPrivateKey) key = RSA.importKey(decryptedPrivateKey) key = key.publickey().exportKey() assert(len(PublicKeys.objects.filter(publicKey=key)) == 1) publicKey = PublicKeys.objects.filter(publicKey=key)[0] challenobj = ChallengeStrings.objects.all() lenofcha = len(challenobj) rannum = lenofcha/2 '''get a random number''' p1 = Votes(plainText=plainText, certificate=certificate, publicKey=publicKey, challengeStr = challenobj[rannum]) p1.save() return True
async def get_ranks(after='1y', sort='top', limit=None): if sort == 'hot': after = '1y' epoch = get_epoch(after) ranks = [] db = DB(DB_FILE) await db.connect() data = await db.get_ranks(epoch, sort, limit) num = 1 async for row in data: bot, link_karma, comment_karma, good_bots, bad_bots, top_score, hot_score, controversial_score = row rank = Bot() rank.name = bot rank.score = top_score votes = Votes() votes.good = good_bots votes.bad = bad_bots rank.votes = votes karma = Karma() karma.link = link_karma karma.comment = comment_karma rank.karma = karma ranks.append(rank) await db.close() for bot in sorted(ranks, key=lambda x: x.score, reverse=True): bot.rank = num num += 1 return ranks
def test_add_one_vote_and_return_100(): add = Votes() add['result'] = 1 add.save() get = report() _sum = get['p1']+get['p2'] assert _sum == 100, _sum
def test_add_three_vote_and_return_100(): for a in [1,2,1]: add = Votes() add['result'] = a add.save() get = report() _sum = get['p1']+get['p2'] assert _sum == 100, _sum
def add_vote(request, poll_id): poll = Poll.objects.get(id=poll_id) choice = Choice.objects.filter(poll=poll_id).order_by('id') if request.method == 'POST': vote = request.POST.get('choice') if vote: vote = Choice.objects.get(id=vote) # saves the poll id, user id, and choice to the votes table v = Votes(poll=poll, choiceVote = vote) v.save() # redirects the user to the results page after they submit their vote return HttpResponseRedirect('../.') return render_to_response('votes.html', {'choice': choice, 'poll': poll, 'vcount': vcount,}, context_instance=RequestContext(request))
def vote_up(request, answer_id): if request.user.is_authenticated(): answer = Answer.objects.get(id = answer_id) votos = Votes.objects.filter(author = request.user, answer = answer) question_id = answer.question.id if len(votos) == 0: voto = Votes(answer = answer, author = request.user, vote = 'Up') voto.save() else: pass #TODO mandar un mensaje de que ya voto. #request.session['message'] = 'Usted ya ha votado por esta repuesta.' return HttpResponseRedirect('/soporte/pregunta/' + str(question_id)) else: return HttpResponseRedirect('/cuentas/login')
def handle_vote(vote): vote_count_up = vote_count('up') vote_count_down = vote_count('down') p_up = percent_up() if not 'vote' in request.cookies: # if the user has not voted, add their vote if market_closed( datetime.utcnow()): # market is closed and its a weekday v = Votes(vote) db.session.add(v) db.session.commit() response = make_response( render_template('poll.html', percent_up=percent_up(), vote_count_up=vote_count('up'), vote_count_down=vote_count('down'), vote=vote)) response.set_cookie('vote', vote) return response else: # user has not voted, but the window is closed return render_template("home.html", percent_up=p_up, vote_count_up=vote_count_up, vote_count_down=vote_count_down) else: # if the user has voted, then display the poll html without adding to db response = make_response( render_template('poll.html', percent_up=p_up, vote_count_up=vote_count_up, vote_count_down=vote_count_down, vote=vote)) return response
def report(): p_1 = Votes.query().filter(result='1').count() p_2 = Votes.query().filter(result='2').count() p1 = 0 if p_1 != 0: p1 = int((p_1*100.00)/(p_1+p_2)) p2 = 0 if p_2 != 0: p2 = int((p_2*100.00)/(p_1+p_2)) if p1 == 0 and p2 == 0: p1 = 50 p2 = 50 return {'p1': p1, 'p2': p2}
async def get_subs(after='1y', limit=None): epoch = get_epoch(after) db = DB(DB_FILE) subs = [] await db.connect() data = await db.get_subs(epoch, limit) async for row in data: sub = Sub() sub.name = row[0] votes = Votes() votes.good = row[1] votes.bad = row[2] sub.votes = votes subs.append(sub) await db.close() return subs
def api_polls(): if request.method == 'POST': # get the poll and save it in the database poll = request.get_json() # simple validation to check if all values are properly set for key, value in poll.items(): if not value: return jsonify( {'message': 'value for {} is empty'.format(key)}) title = poll['title'] options_query = lambda option: Options.query.filter( Options.name.like(option)) options = [ Votes(option=Options( name=option)) if options_query(option).count() == 0 else Votes( option=options_query(option).first()) for option in poll['options'] ] eta = datetime.utcfromtimestamp(poll['close_date']) new_poll = Polls(title=title, options=options, close_date=eta, voting_method=0) db.session.add(new_poll) db.session.commit() # run the task from tasks import close_poll close_poll.apply_async((new_poll.id, SQLALCHEMY_DATABASE_URI), eta=eta) return jsonify({'message': 'Poll was created succesfully'}) else: # it's a GET request, return dict representations of the API polls = Polls.query.filter_by(status=True).join(Votes).order_by( Polls.id.desc()).all() all_polls = {'Polls': [poll.to_json() for poll in polls]} return jsonify(all_polls)
def api_poll_vote(): poll = request.get_json() poll_title, option_name = (poll['poll_title'], poll['option']) join_tables = Votes.query.join(Polls).join(Options) # Get votes, poll, username, and option from the database poll = Polls.query.filter_by(title=poll_title, status=True).first() user = Users.query.filter_by(username=session['user']).first() option = Options.query.filter_by(name=option_name).first() # if poll was closed in the background before user voted if not poll: return jsonify({'message': 'Sorry! this poll has been closed'}) # filter option names option_name = join_tables.filter( Polls.title.like(poll_title), Polls.status == True).filter(Options.name.like(option_name)).first() if option_name: # check if the user has voted on this poll poll_count = UserPolls.query.filter_by(poll_id=poll.id).filter_by( user_id=user.id).filter_by(option_id=option.id).count() if poll_count > 0: return jsonify( {'message': 'Sorry! multiple votes are not allowed'}) # record userpoll and vote user_poll = UserPolls(poll_id=poll.id, user_id=user.id, option_id=option.id) user_vote = Votes(poll_id=poll.id, user_id=user.id, option_id=option.id, vote_count=0) db.session.add(user_poll) db.session.add(user_vote) # increment vote_count by 1 if the option was found option_name.vote_count += 1 db.session.commit() return jsonify({'message': 'Thank you for voting'}) return jsonify( {'message': 'Option or poll was not found please try again'})
def save_vote(): # Get the team and time the vote was cast. team = request.form["team"] time_cast = datetime.datetime.utcnow() if team != "TABS" and team != "SPACES": return Response(response="Invalid team specified.", status=400) try: with session_scope() as session: session.add(Votes(time_cast=time_cast, candidate=team)) except Exception as e: return Response( status=500, response="Unable to successfully cast vote!", ) return Response( status=200, response="Vote successfully cast for '{}'".format(team), )
def addVotes(plainText, certificate): p1 = Votes(plainText=plainText, certificate=certificate) p1.save()
def addVotes(plainText,certificate): p1 = Votes(plainText=plainText, certificate=certificate) p1.save()
async def get_graph(after='1y'): epoch = get_epoch(after) db = DB(DB_FILE) await db.connect() results = {} if 'd' in after: for i in range(24): results[str(i)] = {'good_votes': 0, 'bad_votes': 0} data = await db.get_timeline_data(epoch, '%H') async for row in data: key, good_votes, bad_votes = row results[str(int(key))] = { 'good_votes': good_votes, 'bad_votes': bad_votes } elif 'w' in after: days_of_week = [ 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday' ] for day in days_of_week: results[day] = {'good_votes': 0, 'bad_votes': 0} data = await db.get_timeline_data(epoch, '%w') async for row in data: key, good_votes, bad_votes = row results[days_of_week[int(key)]] = { 'good_votes': good_votes, 'bad_votes': bad_votes } elif 'M' in after: for i in range(31): results[str(i)] = {'good_votes': 0, 'bad_votes': 0} data = await db.get_timeline_data(epoch, '%d') async for row in data: key, good_votes, bad_votes = row results[str(int(key))] = { 'good_votes': good_votes, 'bad_votes': bad_votes } else: months_of_year = [ 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December' ] for month in months_of_year: results[month] = {'good_votes': 0, 'bad_votes': 0} data = await db.get_timeline_data(epoch, '%m') async for row in data: key, good_votes, bad_votes = row results[months_of_year[int(key) - 1]] = { 'good_votes': good_votes, 'bad_votes': bad_votes } graph = Graph() graph.labels = [] graph.votes = [] for key in results: good_votes = results[key]['good_votes'] bad_votes = results[key]['bad_votes'] graph.labels.append(key) votes = Votes() votes.good = good_votes votes.bad = bad_votes graph.votes.append(votes) await db.close() return graph