OpenSlides/openslides/assignment/models.py

334 lines
11 KiB
Python
Raw Normal View History

2011-07-31 10:46:29 +02:00
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
openslides.assignment.models
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Models for the assignment app.
2012-04-25 22:29:19 +02:00
:copyright: 2011, 2012 by OpenSlides team, see AUTHORS.
2011-07-31 10:46:29 +02:00
:license: GNU GPL, see LICENSE for more details.
"""
2012-06-11 13:43:48 +02:00
from django.core.urlresolvers import reverse
2012-07-10 11:27:06 +02:00
from django.db import models
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _, ugettext_noop
2011-07-31 10:46:29 +02:00
from openslides.utils.person import PersonField
2012-07-10 11:27:06 +02:00
from openslides.config.models import config
from openslides.config.signals import default_config_value
2012-07-10 11:27:06 +02:00
from openslides.projector.api import register_slidemodel
from openslides.projector.projector import SlideMixin
2011-07-31 10:46:29 +02:00
2012-07-10 11:27:06 +02:00
from openslides.poll.models import (BasePoll, CountInvalid, CountVotesCast,
BaseOption, PublishPollMixin, BaseVote)
from openslides.agenda.models import Item
class AssignmentCandidate(models.Model):
assignment = models.ForeignKey("Assignment")
person = PersonField(db_index=True)
elected = models.BooleanField(default=False)
blocked = models.BooleanField(default=False)
def __unicode__(self):
return unicode(self.person)
class Meta:
unique_together = ("assignment", "person")
2012-03-03 09:11:56 +01:00
class Assignment(models.Model, SlideMixin):
prefix = 'assignment'
2011-07-31 10:46:29 +02:00
STATUS = (
('sea', _('Searching for candidates')),
('vot', _('Voting')),
('fin', _('Finished')),
)
name = models.CharField(max_length=100, verbose_name=_("Name"))
2012-07-10 11:27:06 +02:00
description = models.TextField(null=True, blank=True,
verbose_name=_("Description"))
posts = models.PositiveSmallIntegerField(
verbose_name=_("Number of available posts"))
polldescription = models.CharField(max_length=100, null=True, blank=True,
verbose_name=_("Comment on the ballot paper"))
status = models.CharField(max_length=3, choices=STATUS, default='sea')
2011-07-31 10:46:29 +02:00
def set_status(self, status):
error = True
for a, b in Assignment.STATUS:
if status == a:
error = False
break
if error:
raise NameError(_('%s is not a valid status.') % status)
if self.status == status:
2012-07-10 11:27:06 +02:00
raise NameError(_('The assignment status is already %s.')
% self.status)
2011-07-31 10:46:29 +02:00
self.status = status
self.save()
def run(self, candidate, person=None):
2011-07-31 10:46:29 +02:00
"""
run for a vote
candidate: The user who will be a candidate
person: The user who chooses the candidate
2011-07-31 10:46:29 +02:00
"""
# TODO: don't make any permission checks here.
# Use other Exceptions
if self.is_candidate(candidate):
raise NameError(_('<b>%s</b> is already a candidate.') % candidate)
if not person.has_perm("assignment.can_manage_assignment") and self.status != 'sea':
raise NameError(_('The candidate list is already closed.'))
candidation = self.assignment_candidates.filter(person=candidate)
if candidation and candidate != person and \
not person.has_perm("assignment.can_manage_assignment"):
# if the candidation is blocked and anotherone tries to run the
# candidate
raise NameError(
2012-09-11 20:50:53 +02:00
_('%s does not want to be a candidate.') % candidate)
elif candidation:
candidation[0].blocked = False
candidation[0].save()
else:
AssignmentCandidate(assignment=self, person=candidate).save()
2011-07-31 10:46:29 +02:00
def delrun(self, candidate, blocked=True):
2011-07-31 10:46:29 +02:00
"""
stop running for a vote
"""
try:
candidation = self.assignment_candidates.get(person=candidate)
except AssignmentCandidate.DoesNotExist:
raise Exception(_('%s is no candidate') % candidate)
if not candidation.blocked:
if blocked:
candidation.blocked = True
candidation.save()
else:
candidation.delete()
2011-07-31 10:46:29 +02:00
else:
candidation.delete()
2011-07-31 10:46:29 +02:00
def is_candidate(self, person):
"""
return True, if person is a candidate.
"""
try:
return self.assignment_candidates.filter(person=person) \
.exclude(blocked=True).exists()
except AttributeError:
return False
2011-07-31 10:46:29 +02:00
def is_blocked(self, person):
"""
return True, if the person is blockt for candidation.
"""
return self.assignment_candidates.filter(person=person) \
.filter(blocked=True).exists()
@property
def assignment_candidates(self):
return AssignmentCandidate.objects.filter(assignment=self)
@property
def candidates(self):
return self.get_participants(only_candidate=True)
@property
def elected(self):
return self.get_participants(only_elected=True)
def get_participants(self, only_elected=False, only_candidate=False):
candidates = self.assignment_candidates.exclude(blocked=True)
2012-07-03 00:05:48 +02:00
2012-09-12 10:17:51 +02:00
assert not (only_elected and only_candidate)
if only_elected:
candidates = candidates.filter(elected=True)
if only_candidate:
candidates = candidates.filter(elected=False)
2012-09-12 10:17:51 +02:00
participants = []
for candidate in candidates.all():
2012-09-12 10:17:51 +02:00
participants.append(candidate.person)
return participants
#return candidates.values_list('person', flat=True)
def set_elected(self, person, value=True):
candidate = self.assignment_candidates.get(person=person)
candidate.elected = value
candidate.save()
def is_elected(self, person):
return person in self.elected
2011-07-31 10:46:29 +02:00
def gen_poll(self):
2012-02-19 19:27:00 +01:00
poll = AssignmentPoll(assignment=self)
2011-07-31 10:46:29 +02:00
poll.save()
poll.set_options([{'candidate': person} for person in self.candidates])
2011-07-31 10:46:29 +02:00
return poll
2012-07-03 00:05:48 +02:00
def vote_results(self, only_published):
2012-07-03 00:05:48 +02:00
"""
returns a table represented as a list with all candidates from all
2012-07-04 11:00:58 +02:00
related polls and their vote results.
2012-07-03 00:05:48 +02:00
"""
vote_results_dict = {}
2012-07-04 11:00:58 +02:00
# All polls related to this assigment
polls = self.poll_set.all()
if only_published:
polls = polls.filter(published=True)
2012-07-04 11:00:58 +02:00
# All PollOption-Objects related to this assignment
2012-07-03 00:05:48 +02:00
options = []
for poll in polls:
options += poll.get_options()
2012-07-03 00:05:48 +02:00
for option in options:
candidate = option.candidate
if candidate in vote_results_dict:
continue
vote_results_dict[candidate] = []
for poll in polls:
votes = {}
2012-07-03 00:05:48 +02:00
try:
# candidate related to this poll
poll_option = poll.get_options().get(candidate=candidate)
for vote in poll_option.get_votes():
votes[vote.value] = vote.print_weight()
2012-07-03 00:05:48 +02:00
except AssignmentOption.DoesNotExist:
2012-07-04 11:00:58 +02:00
# candidate not in related to this poll
votes = None
vote_results_dict[candidate].append(votes)
2012-07-03 00:05:48 +02:00
return vote_results_dict
2012-06-23 10:27:58 +02:00
def get_agenda_title(self):
return self.name
def delete(self):
2012-10-24 11:04:23 +02:00
# Remove any Agenda-Item, which is related to this assignment.
2012-07-04 11:00:58 +02:00
for item in Item.objects.filter(related_sid=self.sid):
item.delete()
super(Assignment, self).delete()
2012-02-06 22:08:08 +01:00
def slide(self):
"""
2012-02-06 22:08:08 +01:00
return the slide dict
"""
polls = self.poll_set
2012-02-06 22:08:08 +01:00
data = super(Assignment, self).slide()
data['assignment'] = self
data['title'] = self.name
data['some_polls_available'] = polls.exists()
data['polls'] = polls.filter(published=True)
data['vote_results'] = self.vote_results(only_published=True)
2012-07-10 11:27:06 +02:00
data['assignment_publish_winner_results_only'] = \
config['assignment_publish_winner_results_only']
2012-02-06 22:08:08 +01:00
data['template'] = 'projector/Assignment.html'
return data
2011-07-31 10:46:29 +02:00
def get_absolute_url(self, link='view'):
if link == 'view':
2012-06-28 01:14:51 +02:00
return reverse('assignment_view', args=[str(self.id)])
2012-06-11 13:43:48 +02:00
if link == 'edit':
2012-06-28 01:14:51 +02:00
return reverse('assignment_edit', args=[str(self.id)])
2011-07-31 10:46:29 +02:00
if link == 'delete':
2012-06-28 01:14:51 +02:00
return reverse('assignment_delete', args=[str(self.id)])
2011-07-31 10:46:29 +02:00
def __unicode__(self):
return self.name
class Meta:
permissions = (
2012-07-10 11:27:06 +02:00
('can_see_assignment', ugettext_noop("Can see assignment")),
('can_nominate_other',
ugettext_noop("Can nominate another person")),
('can_nominate_self', ugettext_noop("Can nominate themselves")),
('can_manage_assignment', ugettext_noop("Can manage assignment")),
2011-07-31 10:46:29 +02:00
)
ordering = ('name',)
2012-04-14 11:18:47 +02:00
register_slidemodel(Assignment)
2012-03-03 11:16:10 +01:00
2012-02-19 19:27:00 +01:00
class AssignmentVote(BaseVote):
option = models.ForeignKey('AssignmentOption')
2012-02-19 19:27:00 +01:00
class AssignmentOption(BaseOption):
poll = models.ForeignKey('AssignmentPoll')
candidate = PersonField()
vote_class = AssignmentVote
2012-02-19 19:27:00 +01:00
def __unicode__(self):
return unicode(self.candidate)
2012-03-03 11:16:10 +01:00
class AssignmentPoll(BasePoll, CountInvalid, CountVotesCast, PublishPollMixin):
2012-02-19 19:27:00 +01:00
option_class = AssignmentOption
assignment = models.ForeignKey(Assignment, related_name='poll_set')
yesnoabstain = models.NullBooleanField()
2012-02-19 19:27:00 +01:00
def get_assignment(self):
return self.assignment
def get_vote_values(self):
if self.yesnoabstain is None:
if config['assignment_poll_vote_values'] == 'votes':
self.yesnoabstain = False
elif config['assignment_poll_vote_values'] == 'yesnoabstain':
self.yesnoabstain = True
else:
# candidates <= available posts -> yes/no/abstain
if len(self.assignment.candidates) <= (self.assignment.posts - len(self.assignment.elected)):
self.yesnoabstain = True
else:
self.yesnoabstain = False
self.save()
if self.yesnoabstain:
return [ugettext_noop('Yes'), ugettext_noop('No'),
ugettext_noop('Abstain')]
else:
return [ugettext_noop('Votes')]
2012-02-19 19:27:00 +01:00
def append_pollform_fields(self, fields):
CountInvalid.append_pollform_fields(self, fields)
CountVotesCast.append_pollform_fields(self, fields)
2012-03-03 11:16:10 +01:00
def get_ballot(self):
return self.assignment.poll_set.filter(id__lte=self.id).count()
@models.permalink
def get_absolute_url(self, link='view'):
if link == 'view':
return ('assignment_poll_view', [str(self.id)])
if link == 'delete':
return ('assignment_poll_delete', [str(self.id)])
def __unicode__(self):
return _("Ballot %d") % self.get_ballot()
2012-03-18 17:11:58 +01:00
@receiver(default_config_value, dispatch_uid="assignment_default_config")
def default_config(sender, key, **kwargs):
return {
2012-04-22 16:55:16 +02:00
'assignment_publish_winner_results_only': False,
'assignment_pdf_ballot_papers_selection': 'CUSTOM_NUMBER',
'assignment_pdf_ballot_papers_number': '8',
'assignment_pdf_title': _('Elections'),
2012-04-22 16:55:16 +02:00
'assignment_pdf_preamble': '',
'assignment_poll_vote_values': 'auto',
}.get(key)