def _update_vote_count(request, votecount, direction):
'''
Evaluates a request's Vote and corresponding VoteCount object and,
after a bit of clever logic, either ignores the request or registers
a new Vote.
This is NOT a view! But should be used within a view ...
Returns True if the request was considered a Vote; returns False if not.
'''
user = request.user
ip_address = get_ip(request)
net_change = 0
# TODO: Rate-limit users based on IP to avoid spamming
#votes_per_ip_limit = getattr(settings, 'VOTECOUNT_VOTES_PER_IP_LIMIT', 0)
# check limit on votes from a unique ip address (VOTECOUNT_VOTES_PER_IP_LIMIT)
#if votes_per_ip_limit:
# if qs.filter(ip_address__exact=ip_address).count() > votes_per_ip_limit:
# return net_change, False
# Check if the user already voted
try:
prev_vote = Vote.objects.get(user=user, votecount=votecount)
# SLOW: Instead of deleting the old and creating a new vote, we really
# should just alter the old vote's direction and then change the
# VoteCounts total accordingly. The VoteCount change should be done
# in the overridden save() method
# Since the user already voted, remove it. Then check if the new vote
# is in a different direction, and if so, create that one
prev_direction = prev_vote.direction
prev_vote.delete()
net_change -= prev_direction
if prev_direction != direction:
# TODO: Is there a better way to refresh this? Like in save()/delete() methods?
# Reload VoteCount from DB since the previous delete() just changed its up/downvote totals
votecount = VoteCount.objects.get(id=votecount.id)
vote = Vote(votecount=votecount,
direction=direction,
ip_address=get_ip(request))
vote.user = user
vote.save()
net_change += direction
except Vote.DoesNotExist:
vote = Vote(votecount=votecount,
direction=direction,
ip_address=get_ip(request))
vote.user = user
vote.save()
net_change += direction
return net_change, True
def _insert_or_update_vote(cart, category, team):
try:
vote = Vote.objects.get(cart=cart, category=category)
if team is None:
vote.delete()
else:
vote.team = team
vote.save()
except:
if team is not None:
vote = Vote(cart=cart, category=category, team=team)
vote.save()
def get_similar_items_from_model(self,
item,
user_list,
model,
min_value=MIN_SIMILARITY_VALUE):
user_item_matrix = self.create_matrix_from_model(user_list, model)
item_user_matrix = self.rotate_matrix(user_item_matrix)
# assert False, (user_item_matrix, item_user_matrix)
sim_list = []
item_list = model.objects.all()
for other in item_list:
if item == other: continue
# assert False, item_user_matrix[item.id]
# sim=utils.distance_matrix_p1_p2(item_user_matrix[item.id],item_user_matrix[other.id]) #returns a 0..1 value
sim = utils.distance_matrix_p1_p2(
item_user_matrix.get(item.id, {1: Vote()}),
item_user_matrix.get(other.id, {1: Vote()}))
"""
sim=utils.distance_matrix_p1_p2(item_user_matrix.get(item.id,
{1:Vote( object=item,
object_id=item.id,
user=user_list[0],
vote=0,
content_type=ContentType.objects.get_for_model(item)
)}),
item_user_matrix.get(other.id,
{1:Vote( object=item,
object_id=item.id,
user=user_list[0],
vote=0,
content_type=ContentType.objects.get_for_model(item)
)}
)) #returns a 0..1 value
"""
if sim > min_value:
sim_list.append((sim, other))
assert False, sim_list
sim_list.sort(reverse=True)
return sim_list
def test_vote_model(self):
vote = Vote()
vote.object_id = self.article._get_pk_val()
vote.content_type = ContentType.objects.get_for_model(self.article)
#vote.content_object = ContentType.objects.get_for_model(self.article)
vote.voter = self.user1
vote.vote = UPVOTE
vote.save()
vote_obj = Vote.objects.all()[0]
self.assertEqual(vote_obj._get_pk_val(), vote._get_pk_val(),
"Primary Keys do not match")
self.assertEqual(vote.vote, vote_obj.vote, "Vote value does not match")
def create(self, validated_data):
print 'In create'
vote = Vote()
vote.voter = validated_data.get('voter')
vote.vote = validated_data.get('vote')
vote.content_type = validated_data.get('content_type')
vote.object_id = validated_data.get('object_id')
#Get row from contentType which has content_type
content_object = ContentType.objects.get_for_id(vote.content_type.id)
vote.content_object = content_object.model_class().objects.get(id=vote.object_id)
"""
Record a user's vote on a given object. Only allows a given user
to vote once, though that vote may be changed.
A zero vote indicates that any existing vote should be removed.
"""
if vote.vote not in (+1, 0, -1):
raise ValueError('Invalid vote (must be +1/0/-1)')
# First, try to fetch the instance of this row from DB
# If that does not exist, then it is the first time we're creating it
# If it does, then just update the previous one
try:
vote_obj = Vote.objects.get(voter=vote.voter, content_type=vote.content_type, object_id=vote.object_id)
if vote == 0 and not ZERO_VOTES_ALLOWED:
vote_obj.delete()
else:
vote_obj.vote = vote
vote_obj.save()
except ObjectDoesNotExist:
#This is the first time we're creating it
try:
if not ZERO_VOTES_ALLOWED and vote == 0:
# This shouldn't be happening actually
return
vote_obj = Vote.objects.create(voter=vote.voter, content_type=vote.content_type, object_id=vote.object_id, vote=vote.vote)
except:
print '{file}: something went wrong in creating a vote object at {line}'.format(file=str('__FILE__'), line=str('__LINE__'))
raise ObjectDoesNotExist
return vote_obj
def index(request):
context={}
if request.method=='POST':
form = voteForm(request.POST)
if form.is_valid():
candidates=Candidate.objects.filter(region=Voter.objects.get(id=request.session['id']).region).values_list('id')
for candidate in candidates:
if(candidate[0]==form.cleaned_data['candidate']):
voted=Vote(voter=request.session['id'],candidate=form.cleaned_data['candidate'])
candidate=Candidate.objects.get(id=form.cleaned_data['candidate'])
candidate.votes=int(candidate.votes)+1
candidate.save()
voted.save()
return HttpResponse('Success')
context['error']="Enter valid id"
return render(request,'voting/index.html',context)
voterid=example_search.pro()
context['showform']=1
if voterid <0:
voterid=100
context['showform']=0
context['voter']=Voter.objects.get(finger=voterid)
print('*************************************')
if ((datetime.now(timezone.utc)-context['voter'].dob).total_seconds()/(365*86400)<18):
context['error']="Underage bitch"
context['showform']=0
print(context['voter'].finger)
check=Vote.objects.filter(voter=context['voter'].id)
print(len(check))
if(len(check)>0):
context['error']="Already Voted"
context['showform']=0
request.session['id']=context['voter'].id
candidates=Candidate.objects.filter(region=context['voter'].region).values_list('id','name')
context['candidates']=candidates
form = voteForm()
context['form']=form
return render(request,'voting/index.html',context)
def poll_detail(request, pk):
"""Jedno konkrétní hlasování"""
## Tahle funkce je složitější, protože zpracovává nejen dotazy na
## aktuální stav (GET), ale i požadavky na změnu stavu (POST) – u nás
## přidání nového záznamu.
## Nejdřív z databáze načteme hlasování zadané v adrese.
## Pokud neexistuje, vrátíme chybu 404 (stránka neexistuje).
poll = get_object_or_404(Poll, pk=pk)
## Nastavíme proměnnou, do které dáme popis chyby, kdyby něco šlo špatně.
error = ''
## A teď: Pokud chtěl uživatel změnit stav (POST), musíme mu zkusit
## vyhovět.
if request.method == 'POST':
## S požadavkem POST by měly přijít informace z formuláře, které nám
## Django zpřístupní ve slovníku "request.POST".
## Očekáváme něco jako:
## {'title': 'Janča', 'opt-1': True, 'opt-3': True}
## t.j. 'title' obsahuje jméno, a 'opt-X', pokud ve slovníku je,
## znamená že uživatel hlasuje pro danou možnost.
## Vezměme si ze slovníku ono jméno.
title = request.POST.get('title')
## Pak si naplníme seznam hlasů.
option_values = []
## Pro každou možnost v tomto hlasování ...
for option in poll.options.all():
## ... zjistíme, jestli je v POST datech příslušný záznam,
if 'opt-{}'.format(option.pk) in request.POST:
value = True
else:
value = False
## A seznam plníme dvojicemi (N-ticemi): (možnost, hodnota).
## ("append" bere jen jeden argument: append(a, b) by nefungovalo,
## závorky navíc znamenají, že metodě posíláme jednu dvojici.)
option_values.append((option, value))
## Jméno musí být vyplněno ...
if title:
## ... a jestli je, zapíšeme do databáze.
## ("with transaction.atomic" říká, že pokud se některý z příkazů
## v tomhle bloku nepovede, databáze zůstane netknutá.
## Je dobré to aspoň pro zápisy do databáze pooužívat.)
with transaction.atomic():
## Vytvoříme nový záznam, a vložíme do databáze
record = Record(poll=poll, title=title)
record.save()
## A pro všechny dvojice (možnost, hodnota), které
## jsme si před chvílí připravili, vytvoříme a uložíme
## odpovídající hlas.
for option, value in option_values:
vote = Vote(option=option, record=record, value=value)
vote.save()
## A potom řekneme prohlížeči, aby stránku načetl znova,
## tentokrát metodou GET.
## (To je proto, že kdyby uživatel stránku načtenou pomocí POST
## obnovil (F5), formulář by se odeslal znovu.)
return redirect('poll_detail', pk=pk)
else:
## Nebyla-li data správná, nastavíme chybovou hlášku.
error = 'Musíš zadat jméno.'
## Formulář teď uživateli ukážeme znova, s chybovou hláškou,
## ale o údaje které vyplnil nepřijde – máme je v "option_values"
## a použijeme je při vytvéření stránky.
else:
## Poslal-li uživatel požadavek GET, nastavíme si "option_values"
## na dvojice jako výše, jen budou všechny hlasy zatím prázdné.
option_values = []
for option in poll.options.all():
option_values.append((option, False))
## Teď můžeme tvořit výslednou stránku. Napřed si pěkně připravíme
## informace pro šablonu...
data = {
'poll': poll, ## Objekt "Hlasování" se všemi informacemi
'error': error, ## Případná chybová hláška
## Dvojice (možnost, hodnota) pro hlasovací formulář
'option_values': option_values,
}
## Informace předáme do šablony, a necháme Django vytvořit stránku.
return render(request, 'voting/poll_detail.html', data)
