be8d6525-f343-4f99-8d6b-8537592c9caf

Committed 12 Oct 2023 11:19AM UTC coverage: 68.011% (+0.3%) from 67.706%

Build # be8d6525-f343-4f99-8d6b-8537592c9caf

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #962 from DemocracyClub/materialized-views

Data explorer interface and CSV export

Run Details

1662 of 2771 branches covered (0.0%)

Branch coverage included in aggregate %.

6 of 6 new or added lines in 1 file covered. (100.0%)

6702 of 9527 relevant lines covered (70.35%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.44

/ynr/apps/elections/models.py

from collections import OrderedDict
from datetime import date

from django.contrib.admin.utils import NestedObjects
from django.db import connection, models
from django.http import QueryDict
from django.shortcuts import get_object_or_404
from django.urls import reverse
from django.utils import timezone
from django.utils.functional import cached_property
from django.utils.http import urlencode
from moderation_queue.models import QueuedImage
from utils.mixins import EEModifiedMixin


class ElectionQuerySet(models.QuerySet):
    def current(self, current=True):
        return self.filter(current=current)

    def future(self):
        return self.filter(election_date__gt=timezone.now())

    def past(self):
        return self.filter(election_date__lt=timezone.now())

    def current_or_future(self):
        return self.filter(
            models.Q(current=True) | models.Q(election_date__gt=timezone.now())
        )

    def get_by_slug(self, election):
        return get_object_or_404(self, slug=election)

    def by_date(self):
        return self.order_by("election_date")


class ElectionManager(models.Manager):
    def are_upcoming_elections(self):
        today = date.today()
        return self.current().filter(election_date__gte=today).exists()


class Election(EEModifiedMixin, models.Model):
    slug = models.CharField(max_length=128, unique=True)
    for_post_role = models.CharField(max_length=128)
    winner_membership_role = models.CharField(
        max_length=128, null=True, blank=True
    )
    candidate_membership_role = models.CharField(max_length=128)
    election_date = models.DateField(db_index=True)
    name = models.CharField(max_length=128)
    current = models.BooleanField()
    use_for_candidate_suggestions = models.BooleanField(default=False)
    organization = models.ForeignKey(
        "popolo.Organization", null=True, blank=True, on_delete=models.CASCADE
    )
    party_lists_in_use = models.BooleanField(default=False)
    people_elected_per_post = models.PositiveSmallIntegerField(
        default=1,
        help_text=(
            "The number of people who are elected per post in this "
            "election. 0 means a variable number of winners"
        ),
    )
    default_party_list_members_to_show = models.PositiveSmallIntegerField(
        default=0
    )
    show_official_documents = models.BooleanField(default=False)
    ocd_division = models.CharField(max_length=250, blank=True)

    description = models.CharField(max_length=500, blank=True)

    modgov_url = models.URLField(
        blank=True,
        null=True,
        help_text="Used to store a possible ModGov url that can be used to scrape information for this election",
    )

    objects = ElectionManager.from_queryset(ElectionQuerySet)()
    UnsafeToDelete = Exception

    def __str__(self):
        return self.name

    def get_absolute_url(self, request=None):
        return reverse("election_view", kwargs={"election": self.slug})

    @property
    def in_past(self):
        return self.election_date < date.today()

    @classmethod
    def group_and_order_elections(cls, include_ballots=False, for_json=False):
        """Group elections in a helpful order

        We should order and group elections in the following way:

          Group by current_or_future=True, then current=False
            Group election by election date (new to old)
              Group by for_post_role (ordered alphabetically)
                Order by election name

        If the parameter include_ballots is set to True, then
        the ballots will be included as well. If for_json is
        True, the returned data should be safe to serialize to JSON (e.g.
        the election dates will be ISO 8601 date strings (i.e. YYYY-MM-DD)
        rather than datetime.date objects).

        e.g. An example of the returned data structure:

        [
          {
            'current_or_future': True,
            'dates': OrderedDict([(datetime.date(2015, 5, 7), [
              {
                'role': 'Member of Parliament',
                'elections': [
                  {
                    'election': <Election: 2015 General Election>,
                    'ballots': [
                      <Post: Member of Parliament for Aberavon>,
                      <Post: Member of Parliament for Aberconwy>,
                      ...
                    ]
                  }
                ]
              }
            ]),
            (datetime.date(2016, 5, 5), [
              {
                'role': 'Member of the Scottish Parliament',
                'elections': [
                  {
                    'election': <Election: 2016 Scottish Parliament Election (Regions)>,
                     'ballots': [
                       <Post: Member of the Scottish Parliament for Central Scotland>,
                       <Post: Member of the Scottish Parliament for Glasgow>,
                       ...
                     ]
                  },
                  {
                    'election': <Election: 2016 Scottish Parliament Election (Constituencies)>,
                    'ballots': [
                      <Post: Member of the Scottish Parliament for Aberdeen Central>,
                      <Post: Member of the Scottish Parliament for Aberdeen Donside>,
                      ...
                    ]
                  }
                ]
              }
            ])])
          },
          {
            'current_or_future': False,
            'dates': OrderedDict([(datetime.date(2010, 5, 6), [
              {
                'role': 'Member of Parliament',
                'elections': [
                  {
                    'election': <Election: 2010 General Election>,
                    'ballots': [
                      <Post: Member of Parliament for Aberavon>,
                      <Post: Member of Parliament for Aberconwy>,
                      ...
                    ]
                  }
                ]
              }
            ])])
          }
        ]

        """
        from candidates.models import Ballot

        result = [{"current_or_future": True, "dates": OrderedDict()}]
        result.append({"current_or_future": False, "dates": OrderedDict()})

        role = None
        qs = cls.objects.order_by(
            "election_date", "-current", "for_post_role", "name"
        )
        # If we've been asked to include ballots as well, add a prefetch
        # to the queryset:
        if include_ballots:
            qs = qs.prefetch_related(
                models.Prefetch(
                    "ballot_set",
                    Ballot.objects.select_related("post")
                    .order_by("post__label")
                    .prefetch_related("suggestedpostlock_set"),
                )
            )

        # The elections and ballots are already sorted into the right
        # order, but now need to be grouped into the useful
        # data structure described in the docstring.
        last_current = None
        for election in qs:
            current_or_future = election.current or not election.in_past
            current_index = 1 - int(current_or_future)
            if for_json:
                election_date = election.election_date.isoformat()
            else:
                election_date = election.election_date
            roles = result[current_index]["dates"].setdefault(election_date, [])
            # If the role has changed, or the election date has changed,
            # or we've switched from current elections to past elections,
            # create a new array of elections to append to:
            if (
                (role is None)
                or role["role"] != election.for_post_role
                or role["elections"][0]["election"].election_date
                != election_date
                or (
                    last_current is not None
                    and last_current != current_or_future
                )
            ):
                role = {"role": election.for_post_role, "elections": []}
                roles.append(role)
            d = {"election": election}
            if include_ballots:
                d["ballots"] = list(election.ballot_set.all())
            role["elections"].append(d)
            last_current = current_or_future

        return result

    def safe_delete(self):
        if self.current:
            raise self.UnsafeToDelete(
                "Can't delete 'current' election {}".format(self.slug)
            )

        collector = NestedObjects(using=connection.cursor().db.alias)
        collector.collect([self])
        if len(collector.nested()) > 1:
            raise self.UnsafeToDelete(
                "Can't delete election {} with related objects".format(
                    self.slug
                )
            )

        self.delete()

    @cached_property
    def get_absolute_queued_image_review_url(self):
        """
        If the ballot has candidates with undecided images, returns a URL to the
        moderation queue list review page, filtered by this ballot paper ID
        """
        if not QueuedImage.objects.filter(
            person__memberships__ballot__election__slug=self.slug
        ).exists():
            return ""

        querystring = urlencode({"election_slug": self.slug})
        url = reverse("photo-review-list")
        return f"{url}?{querystring}"

    def get_csv_url(self):
        params = QueryDict("", mutable=True)
        params["election_id"] = self.slug
        url = reverse("data_export")
        return f"{url}?{params.urlencode()}"

1	from collections import OrderedDict	1✔
2	from datetime import date	1✔
3
4	from django.contrib.admin.utils import NestedObjects	1✔
5	from django.db import connection, models	1✔
6	from django.http import QueryDict	1✔
7	from django.shortcuts import get_object_or_404	1✔
8	from django.urls import reverse	1✔
9	from django.utils import timezone	1✔
10	from django.utils.functional import cached_property	1✔
11	from django.utils.http import urlencode	1✔
12	from moderation_queue.models import QueuedImage	1✔
13	from utils.mixins import EEModifiedMixin	1✔
14
15
16	class ElectionQuerySet(models.QuerySet):	1✔
17	def current(self, current=True):	1✔
18	return self.filter(current=current)	1✔
19
20	def future(self):	1✔
21	return self.filter(election_date__gt=timezone.now())	1✔
22
23	def past(self):	1✔
24	return self.filter(election_date__lt=timezone.now())	×
25
26	def current_or_future(self):	1✔
27	return self.filter(	1✔
28	models.Q(current=True) \| models.Q(election_date__gt=timezone.now())
29	)
30
31	def get_by_slug(self, election):	1✔
32	return get_object_or_404(self, slug=election)	×
33
34	def by_date(self):	1✔
35	return self.order_by("election_date")	×
36
37
38	class ElectionManager(models.Manager):	1✔
39	def are_upcoming_elections(self):	1✔
40	today = date.today()	1✔
41	return self.current().filter(election_date__gte=today).exists()	1✔
42
43
44	class Election(EEModifiedMixin, models.Model):	1✔
45	slug = models.CharField(max_length=128, unique=True)	1✔
46	for_post_role = models.CharField(max_length=128)	1✔
47	winner_membership_role = models.CharField(	1✔
48	max_length=128, null=True, blank=True
49	)
50	candidate_membership_role = models.CharField(max_length=128)	1✔
51	election_date = models.DateField(db_index=True)	1✔
52	name = models.CharField(max_length=128)	1✔
53	current = models.BooleanField()	1✔
54	use_for_candidate_suggestions = models.BooleanField(default=False)	1✔
55	organization = models.ForeignKey(	1✔
56	"popolo.Organization", null=True, blank=True, on_delete=models.CASCADE
57	)
58	party_lists_in_use = models.BooleanField(default=False)	1✔
59	people_elected_per_post = models.PositiveSmallIntegerField(	1✔
60	default=1,
61	help_text=(
62	"The number of people who are elected per post in this "
63	"election. 0 means a variable number of winners"
64	),
65	)
66	default_party_list_members_to_show = models.PositiveSmallIntegerField(	1✔
67	default=0
68	)
69	show_official_documents = models.BooleanField(default=False)	1✔
70	ocd_division = models.CharField(max_length=250, blank=True)	1✔
71
72	description = models.CharField(max_length=500, blank=True)	1✔
73
74	modgov_url = models.URLField(	1✔
75	blank=True,
76	null=True,
77	help_text="Used to store a possible ModGov url that can be used to scrape information for this election",
78	)
79
80	objects = ElectionManager.from_queryset(ElectionQuerySet)()	1✔
81	UnsafeToDelete = Exception	1✔
82
83	def __str__(self):	1✔
84	return self.name	1✔
85
86	def get_absolute_url(self, request=None):	1✔
87	return reverse("election_view", kwargs={"election": self.slug})	1✔
88
89	@property	1✔
90	def in_past(self):	1✔
91	return self.election_date < date.today()	1✔
92
93	@classmethod	1✔
94	def group_and_order_elections(cls, include_ballots=False, for_json=False):	1✔
95	"""Group elections in a helpful order
96
97	We should order and group elections in the following way:
98
99	Group by current_or_future=True, then current=False
100	Group election by election date (new to old)
101	Group by for_post_role (ordered alphabetically)
102	Order by election name
103
104	If the parameter include_ballots is set to True, then
105	the ballots will be included as well. If for_json is
106	True, the returned data should be safe to serialize to JSON (e.g.
107	the election dates will be ISO 8601 date strings (i.e. YYYY-MM-DD)
108	rather than datetime.date objects).
109
110	e.g. An example of the returned data structure:
111
112	[
113	{
114	'current_or_future': True,
115	'dates': OrderedDict([(datetime.date(2015, 5, 7), [
116	{
117	'role': 'Member of Parliament',
118	'elections': [
119	{
120	'election': <Election: 2015 General Election>,
121	'ballots': [
122	<Post: Member of Parliament for Aberavon>,
123	<Post: Member of Parliament for Aberconwy>,
124	...
125	]
126	}
127	]
128	}
129	]),
130	(datetime.date(2016, 5, 5), [
131	{
132	'role': 'Member of the Scottish Parliament',
133	'elections': [
134	{
135	'election': <Election: 2016 Scottish Parliament Election (Regions)>,
136	'ballots': [
137	<Post: Member of the Scottish Parliament for Central Scotland>,
138	<Post: Member of the Scottish Parliament for Glasgow>,
139	...
140	]
141	},
142	{
143	'election': <Election: 2016 Scottish Parliament Election (Constituencies)>,
144	'ballots': [
145	<Post: Member of the Scottish Parliament for Aberdeen Central>,
146	<Post: Member of the Scottish Parliament for Aberdeen Donside>,
147	...
148	]
149	}
150	]
151	}
152	])])
153	},
154	{
155	'current_or_future': False,
156	'dates': OrderedDict([(datetime.date(2010, 5, 6), [
157	{
158	'role': 'Member of Parliament',
159	'elections': [
160	{
161	'election': <Election: 2010 General Election>,
162	'ballots': [
163	<Post: Member of Parliament for Aberavon>,
164	<Post: Member of Parliament for Aberconwy>,
165	...
166	]
167	}
168	]
169	}
170	])])
171	}
172	]
173
174	"""
175	from candidates.models import Ballot	1✔
176
177	result = [{"current_or_future": True, "dates": OrderedDict()}]	1✔
178	result.append({"current_or_future": False, "dates": OrderedDict()})	1✔
179
180	role = None	1✔
181	qs = cls.objects.order_by(	1✔
182	"election_date", "-current", "for_post_role", "name"
183	)
184	# If we've been asked to include ballots as well, add a prefetch
185	# to the queryset:
186	if include_ballots:	1✔
187	qs = qs.prefetch_related(	1✔
188	models.Prefetch(
189	"ballot_set",
190	Ballot.objects.select_related("post")
191	.order_by("post__label")
192	.prefetch_related("suggestedpostlock_set"),
193	)
194	)
195
196	# The elections and ballots are already sorted into the right
197	# order, but now need to be grouped into the useful
198	# data structure described in the docstring.
199	last_current = None	1✔
200	for election in qs:	1✔
201	current_or_future = election.current or not election.in_past	1✔
202	current_index = 1 - int(current_or_future)	1✔
203	if for_json:	1✔
204	election_date = election.election_date.isoformat()	1✔
205	else:
206	election_date = election.election_date	1✔
207	roles = result[current_index]["dates"].setdefault(election_date, [])	1✔
208	# If the role has changed, or the election date has changed,
209	# or we've switched from current elections to past elections,
210	# create a new array of elections to append to:
211	if (	1✔
212	(role is None)
213	or role["role"] != election.for_post_role
214	or role["elections"][0]["election"].election_date
215	!= election_date
216	or (
217	last_current is not None
218	and last_current != current_or_future
219	)
220	):
221	role = {"role": election.for_post_role, "elections": []}	1✔
222	roles.append(role)	1✔
223	d = {"election": election}	1✔
224	if include_ballots:	1✔
225	d["ballots"] = list(election.ballot_set.all())	1✔
226	role["elections"].append(d)	1✔
227	last_current = current_or_future	1✔
228
229	return result	1✔
230
231	def safe_delete(self):	1✔
232	if self.current:	1✔
233	raise self.UnsafeToDelete(	1✔
234	"Can't delete 'current' election {}".format(self.slug)
235	)
236
237	collector = NestedObjects(using=connection.cursor().db.alias)	1✔
238	collector.collect([self])	1✔
239	if len(collector.nested()) > 1:	1!
240	raise self.UnsafeToDelete(	×
241	"Can't delete election {} with related objects".format(
242	self.slug
243	)
244	)
245
246	self.delete()	1✔
247
248	@cached_property	1✔
249	def get_absolute_queued_image_review_url(self):	1✔
250	"""
251	If the ballot has candidates with undecided images, returns a URL to the
252	moderation queue list review page, filtered by this ballot paper ID
253	"""
254	if not QueuedImage.objects.filter(	×
255	person__memberships__ballot__election__slug=self.slug
256	).exists():
257	return ""	×
258
259	querystring = urlencode({"election_slug": self.slug})	×
260	url = reverse("photo-review-list")	×
261	return f"{url}?{querystring}"	×
262
263	def get_csv_url(self):	1✔
264	params = QueryDict("", mutable=True)	×
265	params["election_id"] = self.slug	×
266	url = reverse("data_export")	×
267	return f"{url}?{params.urlencode()}"	×

DemocracyClub / yournextrepresentative / be8d6525-f343-4f99-8d6b-8537592c9caf

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous