OpenSlides/openslides/assignments/models.py

420 lines
12 KiB
Python
Raw Normal View History

from collections import OrderedDict
from decimal import Decimal
2018-08-22 22:00:08 +02:00
from typing import Any, Dict, List
from django.conf import settings
from django.core.validators import MinValueValidator
2012-07-10 11:27:06 +02:00
from django.db import models
2011-07-31 10:46:29 +02:00
from openslides.agenda.mixins import AgendaItemWithListOfSpeakersMixin
from openslides.agenda.models import Speaker
2015-06-29 12:08:15 +02:00
from openslides.core.config import config
2018-12-23 11:05:38 +01:00
from openslides.core.models import Tag
2019-04-26 13:25:45 +02:00
from openslides.mediafiles.models import Mediafile
from openslides.poll.models import (
BaseOption,
BasePoll,
BaseVote,
CollectDefaultVotesMixin,
PublishPollMixin,
)
2016-10-01 01:30:55 +02:00
from openslides.utils.autoupdate import inform_changed_data
from openslides.utils.exceptions import OpenSlidesError
from openslides.utils.models import RESTModelMixin
from ..utils.models import CASCADE_AND_AUTOUODATE, SET_NULL_AND_AUTOUPDATE
from .access_permissions import AssignmentAccessPermissions
class AssignmentRelatedUser(RESTModelMixin, models.Model):
"""
Many to Many table between an assignment and user.
"""
2016-12-06 12:21:29 +01:00
assignment = models.ForeignKey(
2019-01-06 16:22:33 +01:00
"Assignment", on_delete=models.CASCADE, related_name="assignment_related_users"
)
2016-12-06 12:21:29 +01:00
"""
ForeinKey to the assignment.
"""
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=CASCADE_AND_AUTOUODATE)
2016-12-06 12:21:29 +01:00
"""
ForeinKey to the user who is related to the assignment.
"""
elected = models.BooleanField(default=False)
2016-12-06 12:21:29 +01:00
"""
Saves the election state of each user
"""
weight = models.IntegerField(default=0)
"""
The sort order of the candidates.
"""
class Meta:
2015-12-10 00:20:59 +01:00
default_permissions = ()
2019-01-06 16:22:33 +01:00
unique_together = ("assignment", "user")
def __str__(self):
2019-01-12 23:01:42 +01:00
return f"{self.assignment} <-> {self.user}"
def get_root_rest_element(self):
"""
Returns the assignment to this instance which is the root REST element.
"""
return self.assignment
class AssignmentManager(models.Manager):
2016-09-30 20:42:58 +02:00
"""
Customized model manager to support our get_full_queryset method.
"""
2019-01-06 16:22:33 +01:00
def get_full_queryset(self):
2016-09-30 20:42:58 +02:00
"""
Returns the normal queryset with all assignments. In the background
all related users (candidates), the related agenda item and all
polls are prefetched from the database.
"""
return self.get_queryset().prefetch_related(
"related_users",
"agenda_items",
"lists_of_speakers",
"polls",
"tags",
"attachments",
2019-01-06 16:22:33 +01:00
)
class Assignment(RESTModelMixin, AgendaItemWithListOfSpeakersMixin, models.Model):
"""
Model for assignments.
"""
2019-01-06 16:22:33 +01:00
access_permissions = AssignmentAccessPermissions()
2019-01-06 16:22:33 +01:00
can_see_permission = "assignments.can_see"
objects = AssignmentManager()
PHASE_SEARCH = 0
PHASE_VOTING = 1
PHASE_FINISHED = 2
PHASES = (
2019-01-06 16:22:33 +01:00
(PHASE_SEARCH, "Searching for candidates"),
(PHASE_VOTING, "Voting"),
(PHASE_FINISHED, "Finished"),
2011-07-31 10:46:29 +02:00
)
2019-01-06 16:22:33 +01:00
title = models.CharField(max_length=100)
"""
Title of the assignment.
"""
2019-01-06 16:22:33 +01:00
description = models.TextField(blank=True)
"""
Text to describe the assignment.
"""
open_posts = models.PositiveSmallIntegerField()
"""
The number of members to be elected.
"""
2019-01-06 16:22:33 +01:00
poll_description_default = models.CharField(max_length=79, blank=True)
"""
Default text for the poll description.
"""
2019-01-06 16:22:33 +01:00
phase = models.IntegerField(choices=PHASES, default=PHASE_SEARCH)
"""
Phase in which the assignment is.
"""
related_users = models.ManyToManyField(
2019-01-06 16:22:33 +01:00
settings.AUTH_USER_MODEL, through="AssignmentRelatedUser"
)
"""
Users that are candidates or elected.
See AssignmentRelatedUser for more information.
"""
tags = models.ManyToManyField(Tag, blank=True)
"""
Tags for the assignment.
"""
2019-04-26 13:25:45 +02:00
attachments = models.ManyToManyField(Mediafile, blank=True)
"""
Mediafiles as attachments for this assignment.
"""
class Meta:
2015-12-10 00:20:59 +01:00
default_permissions = ()
permissions = (
2019-01-06 16:22:33 +01:00
("can_see", "Can see elections"),
("can_nominate_other", "Can nominate another participant"),
("can_nominate_self", "Can nominate oneself"),
("can_manage", "Can manage elections"),
)
2019-01-06 16:22:33 +01:00
ordering = ("title",)
2019-01-12 23:01:42 +01:00
verbose_name = "Election"
def __str__(self):
return self.title
@property
def candidates(self):
2011-07-31 10:46:29 +02:00
"""
Queryset that represents the candidates for the assignment.
2011-07-31 10:46:29 +02:00
"""
2019-01-06 16:22:33 +01:00
return self.related_users.filter(assignmentrelateduser__elected=False)
@property
def elected(self):
"""
Queryset that represents all elected users for the assignment.
"""
2019-01-06 16:22:33 +01:00
return self.related_users.filter(assignmentrelateduser__elected=True)
2011-07-31 10:46:29 +02:00
def is_candidate(self, user):
"""
Returns True if user is a candidate.
Costs one database query.
"""
return self.candidates.filter(pk=user.pk).exists()
def is_elected(self, user):
"""
Returns True if the user is elected for this assignment.
Costs one database query.
"""
return self.elected.filter(pk=user.pk).exists()
def set_candidate(self, user):
"""
Adds the user as candidate.
"""
2019-01-06 16:22:33 +01:00
weight = (
self.assignment_related_users.aggregate(models.Max("weight"))["weight__max"]
or 0
)
defaults = {"elected": False, "weight": weight + 1}
2019-01-12 23:01:42 +01:00
self.assignment_related_users.update_or_create(user=user, defaults=defaults)
2012-07-03 00:05:48 +02:00
def set_elected(self, user):
"""
Makes user an elected user for this assignment.
"""
2019-01-12 23:01:42 +01:00
self.assignment_related_users.update_or_create(
2019-01-06 16:22:33 +01:00
user=user, defaults={"elected": True}
)
def delete_related_user(self, user):
"""
Delete the connection from the assignment to the user.
"""
self.assignment_related_users.filter(user=user).delete()
2016-10-01 01:30:55 +02:00
inform_changed_data(self)
def set_phase(self, phase):
"""
Sets the phase attribute of the assignment.
Raises a ValueError if the phase is not valide.
"""
if phase not in dict(self.PHASES):
2019-01-12 23:01:42 +01:00
raise ValueError(f"Invalid phase {phase}")
self.phase = phase
def create_poll(self):
"""
Creates a new poll for the assignment and adds all candidates to all
lists of speakers of related agenda items.
"""
candidates = self.candidates.all()
# Find out the method of the election
2019-01-06 16:22:33 +01:00
if config["assignments_poll_vote_values"] == "votes":
pollmethod = "votes"
elif config["assignments_poll_vote_values"] == "yesnoabstain":
pollmethod = "yna"
elif config["assignments_poll_vote_values"] == "yesno":
pollmethod = "yn"
else:
# config['assignments_poll_vote_values'] == 'auto'
# candidates <= available posts -> yes/no/abstain
if len(candidates) <= (self.open_posts - self.elected.count()):
2019-01-06 16:22:33 +01:00
pollmethod = "yna"
else:
2019-01-06 16:22:33 +01:00
pollmethod = "votes"
# Create the poll with the candidates.
poll = self.polls.create(
2019-01-06 16:22:33 +01:00
description=self.poll_description_default, pollmethod=pollmethod
)
2016-12-06 12:21:29 +01:00
options = []
2019-01-06 16:22:33 +01:00
related_users = AssignmentRelatedUser.objects.filter(
assignment__id=self.id
).exclude(elected=True)
2016-12-06 12:21:29 +01:00
for related_user in related_users:
2019-01-06 16:22:33 +01:00
options.append(
{"candidate": related_user.user, "weight": related_user.weight}
)
poll.set_options(options, skip_autoupdate=True)
inform_changed_data(self)
# Add all candidates to list of speakers of related agenda item
# TODO: Try to do this in a bulk create
2019-01-06 16:22:33 +01:00
if config["assignments_add_candidates_to_list_of_speakers"]:
for candidate in self.candidates:
try:
2019-01-06 16:22:33 +01:00
Speaker.objects.add(
candidate, self.list_of_speakers, skip_autoupdate=True
2019-01-06 16:22:33 +01:00
)
except OpenSlidesError:
# The Speaker is already on the list. Do nothing.
# TODO: Find a smart way not to catch the error concerning AnonymousUser.
pass
inform_changed_data(self.list_of_speakers)
2011-07-31 10:46:29 +02:00
return poll
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
"""
2018-08-22 22:00:08 +02:00
vote_results_dict: Dict[Any, List[AssignmentVote]] = OrderedDict()
polls = self.polls.all()
if only_published:
polls = polls.filter(published=True)
2012-07-04 11:00:58 +02:00
# All PollOption-Objects related to this assignment
2018-08-22 22:00:08 +02:00
options: List[AssignmentOption] = []
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:
2018-08-22 22:00:08 +02:00
votes: Any = {}
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
def get_title_information(self):
2019-02-15 12:17:08 +01:00
return {"title": self.title}
2012-02-19 19:27:00 +01:00
class AssignmentVote(RESTModelMixin, BaseVote):
option = models.ForeignKey(
2019-01-06 16:22:33 +01:00
"AssignmentOption", on_delete=models.CASCADE, related_name="votes"
)
2015-12-10 00:20:59 +01:00
class Meta:
default_permissions = ()
def get_root_rest_element(self):
"""
Returns the assignment to this instance which is the root REST element.
"""
return self.option.poll.assignment
class AssignmentOption(RESTModelMixin, BaseOption):
poll = models.ForeignKey(
2019-01-06 16:22:33 +01:00
"AssignmentPoll", on_delete=models.CASCADE, related_name="options"
)
candidate = models.ForeignKey(
settings.AUTH_USER_MODEL, on_delete=SET_NULL_AND_AUTOUPDATE, null=True
)
2016-12-06 12:21:29 +01:00
weight = models.IntegerField(default=0)
vote_class = AssignmentVote
2012-02-19 19:27:00 +01:00
2015-12-10 00:20:59 +01:00
class Meta:
default_permissions = ()
def __str__(self):
return str(self.candidate)
2012-02-19 19:27:00 +01:00
def get_root_rest_element(self):
"""
Returns the assignment to this instance which is the root REST element.
"""
return self.poll.assignment
2012-02-19 19:27:00 +01:00
2017-08-23 20:51:06 +02:00
# TODO: remove the type-ignoring in the next line, after this is solved:
# https://github.com/python/mypy/issues/3855
2019-01-06 16:22:33 +01:00
class AssignmentPoll( # type: ignore
RESTModelMixin, CollectDefaultVotesMixin, PublishPollMixin, BasePoll
):
2012-02-19 19:27:00 +01:00
option_class = AssignmentOption
assignment = models.ForeignKey(
2019-01-06 16:22:33 +01:00
Assignment, on_delete=models.CASCADE, related_name="polls"
)
pollmethod = models.CharField(max_length=5, default="yna")
description = models.CharField(max_length=79, blank=True)
votesabstain = models.DecimalField(
null=True,
blank=True,
validators=[MinValueValidator(Decimal("-2"))],
max_digits=15,
decimal_places=6,
)
""" General abstain votes, used for pollmethod 'votes' """
2019-01-06 16:22:33 +01:00
votesno = models.DecimalField(
null=True,
blank=True,
validators=[MinValueValidator(Decimal("-2"))],
max_digits=15,
decimal_places=6,
)
""" General no votes, used for pollmethod 'votes' """
2015-12-10 00:20:59 +01:00
class Meta:
default_permissions = ()
2012-02-19 19:27:00 +01:00
def get_assignment(self):
return self.assignment
def get_vote_values(self):
2019-01-06 16:22:33 +01:00
if self.pollmethod == "yna":
return ["Yes", "No", "Abstain"]
2019-01-12 23:01:42 +01:00
if self.pollmethod == "yn":
2019-01-06 16:22:33 +01:00
return ["Yes", "No"]
2019-01-12 23:01:42 +01:00
return ["Votes"]
def get_ballot(self):
return self.assignment.polls.filter(id__lte=self.pk).count()
def get_percent_base_choice(self):
2019-01-06 16:22:33 +01:00
return config["assignments_poll_100_percent_base"]
def get_root_rest_element(self):
"""
Returns the assignment to this instance which is the root REST element.
"""
return self.assignment