86cabedc-d736-4dbd-b64d-b716fa281168

Committed 04 Apr 2024 02:16PM UTC coverage: 68.236% (+1.0%) from 67.282%

Build # 86cabedc-d736-4dbd-b64d-b716fa281168

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #2269 from DemocracyClub/feature/redesign-sopn-models

Redesign SOPN models

Run Details

1749 of 2926 branches covered (59.77%)

Branch coverage included in aggregate %.

415 of 509 new or added lines in 26 files covered. (81.53%)

18 existing lines in 4 files now uncovered.

7093 of 10032 relevant lines covered (70.7%)

0.71 hits per line

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

91.74

/ynr/apps/official_documents/views.py

import json

from auth_helpers.views import GroupRequiredMixin
from candidates.models import Ballot, LoggedAction
from candidates.models.db import ActionType, EditType
from candidates.views.version_data import get_client_ip
from django.http.response import HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.template.loader import render_to_string
from django.views.generic import (
    CreateView,
    DetailView,
    TemplateView,
    UpdateView,
)
from elections.models import Election
from moderation_queue.models import SuggestedPostLock
from sopn_parsing.helpers.text_helpers import NoTextInDocumentError

from .extract_pages import ElectionSOPNPageSplitter
from .forms import UploadBallotSOPNForm, UploadElectionSOPNForm
from .models import (
    DOCUMENT_UPLOADERS_GROUP_NAME,
    BallotSOPN,
    PageMatchingMethods,
)


class CreateOrUpdateBallotSOPNView(GroupRequiredMixin, UpdateView):
    required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME

    form_class = UploadBallotSOPNForm
    template_name = "official_documents/upload_ballot_sopn_form.html"
    model = BallotSOPN

    def get_initial(self):
        return {
            "ballot": self.ballot,
        }

    def get_object(self, queryset=None):
        self.ballot = Ballot.objects.get(
            ballot_paper_id=self.kwargs["ballot_paper_id"]
        )
        if existing_ballot_sopn := getattr(self.ballot, "sopn", None):
            obj = existing_ballot_sopn
        else:
            obj = self.model()
        return obj

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        ballot = get_object_or_404(
            Ballot, ballot_paper_id=self.kwargs["ballot_paper_id"]
        )
        context["ballot"] = ballot
        context["post_label"] = ballot.post.label
        return context

    def form_valid(self, form):
        """
        Saves the SOPN and attempts to parse the PDF to extract the candidate
        information. This fails silently to avoid a 500 error if the PDF cannot
        be parsed. We always save the file even if it cannot be parsed, then
        create a LoggedAction and redirect the user.
        """
        self.object = form.save()
        try:
            if hasattr(self.object.ballot, "rawpeople"):
                self.object.ballot.rawpeople.delete()
            # TODO: add back in
            # extract_pages_for_ballot(ballot=self.object.ballot)
            # extract_ballot_table(ballot=self.object.ballot)
            # parse_raw_data_for_ballot(ballot=self.object.ballot)
        except (ValueError, NoTextInDocumentError):
            # If PDF couldnt be parsed continue
            # TODO should be log this error?
            pass

        LoggedAction.objects.create(
            user=self.request.user,
            ballot=self.object.ballot,
            action_type=ActionType.SOPN_UPLOAD,
            ip_address=get_client_ip(self.request),
            source=self.object.source_url,
        )
        self.object.parse()
        return HttpResponseRedirect(self.get_success_url())


class CreateElectionSOPNView(GroupRequiredMixin, CreateView):
    required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME

    form_class = UploadElectionSOPNForm
    template_name = "official_documents/upload_election_sopn_form.html"

    def get_initial(self):
        return {
            "election": Election.objects.get(slug=self.kwargs["election_id"]),
        }

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        election = get_object_or_404(Election, slug=self.kwargs["election_id"])
        context["election"] = election
        return context

    def form_valid(self, form):
        ret = super().form_valid(form)
        LoggedAction.objects.create(
            user=self.request.user,
            election=self.object.election,
            action_type=ActionType.SOPN_UPLOAD,
            ip_address=get_client_ip(self.request),
            source=self.object.source_url,
            edit_type=EditType.USER,
        )
        return ret


class ElectionSOPNMatchingView(GroupRequiredMixin, DetailView):
    required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME
    template_name = "official_documents/election_sopn_matcher.html"
    queryset = (
        Election.objects.all()
        .select_related("electionsopn")
        .prefetch_related("ballot_set")
    )
    slug_url_kwarg = "election_id"
    slug_field = "slug"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        ballot_data = []
        for ballot in self.object.ballot_set.all().order_by("post__label"):
            ballot_for_matcher = {
                "ballot_paper_id": ballot.ballot_paper_id,
                "label": ballot.post.label,
            }
            if (
                self.object.electionsopn.pages_matched
                and ballot.sopn.relevant_pages != "all"
            ):
                ballot_for_matcher["matched"] = bool(ballot.sopn.relevant_pages)
                ballot_for_matcher["matched_page"] = str(
                    ballot.sopn.first_page_int
                )
            ballot_data.append(ballot_for_matcher)

        context["matcher_props"] = {
            "election_id": self.object.name,
            "sopn_pdf": self.object.electionsopn.uploaded_file.url,
            "ballots": ballot_data,
        }
        return context

    def post(self, request, election_id):
        election = self.get_object()
        splitter = ElectionSOPNPageSplitter(
            election.electionsopn, json.loads(request.POST.get("matched_pages"))
        )
        splitter.split(method=PageMatchingMethods.MANUAL_MATCHED)
        LoggedAction.objects.create(
            user=request.user,
            election=election,
            action_type=ActionType.SOPN_SPLIT_BALLOTS,
            ip_address=get_client_ip(request),
            source="Manual matching",
            edit_type=EditType.USER,
        )
        return HttpResponseRedirect(election.electionsopn.get_absolute_url())


class PostsForDocumentView(DetailView):
    model = BallotSOPN
    template_name = "official_documents/posts_for_document.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        documents = (
            BallotSOPN.objects.filter(source_url=self.object.source_url)
            .distinct("ballot__ballot_paper_id")
            .filter(ballot__election=self.object.ballot.election)
            .select_related("ballot__post", "ballot__election")
            .order_by("ballot__ballot_paper_id")
            .prefetch_related("ballot__suggestedpostlock_set")
        )

        context["document_posts"] = documents

        return context


def get_add_from_document_cta_flash_message(document, remaining_posts):
    return render_to_string(
        "official_documents/_add_from_document_cta_flash_message.html",
        {"document": document, "remaining_posts": remaining_posts},
    )


class UnlockedWithDocumentsView(TemplateView):
    template_name = "official_documents/unlocked_with_documents.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        SOPNs_qs = BallotSOPN.objects.filter(
            ballot__election__current=True
        ).select_related("ballot__election", "ballot__post")

        SOPNs_qs = SOPNs_qs.exclude(
            ballot__post__in=SuggestedPostLock.objects.all().values(
                "ballot__post"
            )
        )

        context["unlocked_sopns"] = SOPNs_qs.filter(
            ballot__candidates_locked=False
        )

        return context

1	import json	1✔
2
3	from auth_helpers.views import GroupRequiredMixin	1✔
4	from candidates.models import Ballot, LoggedAction	1✔
5	from candidates.models.db import ActionType, EditType	1✔
6	from candidates.views.version_data import get_client_ip	1✔
7	from django.http.response import HttpResponseRedirect	1✔
8	from django.shortcuts import get_object_or_404	1✔
9	from django.template.loader import render_to_string	1✔
10	from django.views.generic import (	1✔
11	CreateView,
12	DetailView,
13	TemplateView,
14	UpdateView,
15	)
16	from elections.models import Election	1✔
17	from moderation_queue.models import SuggestedPostLock	1✔
18	from sopn_parsing.helpers.text_helpers import NoTextInDocumentError	1✔
19
20	from .extract_pages import ElectionSOPNPageSplitter	1✔
21	from .forms import UploadBallotSOPNForm, UploadElectionSOPNForm	1✔
22	from .models import (	1✔
23	DOCUMENT_UPLOADERS_GROUP_NAME,
24	BallotSOPN,
25	PageMatchingMethods,
26	)
27
28
29	class CreateOrUpdateBallotSOPNView(GroupRequiredMixin, UpdateView):	1✔
30	required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME	1✔
31
32	form_class = UploadBallotSOPNForm	1✔
33	template_name = "official_documents/upload_ballot_sopn_form.html"	1✔
34	model = BallotSOPN	1✔
35
36	def get_initial(self):	1✔
37	return {	1✔
38	"ballot": self.ballot,
39	}
40
41	def get_object(self, queryset=None):	1✔
42	self.ballot = Ballot.objects.get(	1✔
43	ballot_paper_id=self.kwargs["ballot_paper_id"]
44	)
45	if existing_ballot_sopn := getattr(self.ballot, "sopn", None):	1!
NEW 46	obj = existing_ballot_sopn	×
47	else:
48	obj = self.model()	1✔
49	return obj	1✔
50
51	def get_context_data(self, **kwargs):	1✔
52	context = super().get_context_data(**kwargs)	1✔
53	ballot = get_object_or_404(	1✔
54	Ballot, ballot_paper_id=self.kwargs["ballot_paper_id"]
55	)
56	context["ballot"] = ballot	1✔
57	context["post_label"] = ballot.post.label	1✔
58	return context	1✔
59
60	def form_valid(self, form):	1✔
61	"""
62	Saves the SOPN and attempts to parse the PDF to extract the candidate
63	information. This fails silently to avoid a 500 error if the PDF cannot
64	be parsed. We always save the file even if it cannot be parsed, then
65	create a LoggedAction and redirect the user.
66	"""
67	self.object = form.save()	1✔
68	try:	1✔
69	if hasattr(self.object.ballot, "rawpeople"):	1!
70	self.object.ballot.rawpeople.delete()	×
71	# TODO: add back in
72	# extract_pages_for_ballot(ballot=self.object.ballot)
73	# extract_ballot_table(ballot=self.object.ballot)
74	# parse_raw_data_for_ballot(ballot=self.object.ballot)
UNCOV 75	except (ValueError, NoTextInDocumentError):	×
76	# If PDF couldnt be parsed continue
77	# TODO should be log this error?
78	pass	×
79
80	LoggedAction.objects.create(	1✔
81	user=self.request.user,
82	ballot=self.object.ballot,
83	action_type=ActionType.SOPN_UPLOAD,
84	ip_address=get_client_ip(self.request),
85	source=self.object.source_url,
86	)
87	self.object.parse()	1✔
88	return HttpResponseRedirect(self.get_success_url())	1✔
89
90
91	class CreateElectionSOPNView(GroupRequiredMixin, CreateView):	1✔
92	required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME	1✔
93
94	form_class = UploadElectionSOPNForm	1✔
95	template_name = "official_documents/upload_election_sopn_form.html"	1✔
96
97	def get_initial(self):	1✔
98	return {	1✔
99	"election": Election.objects.get(slug=self.kwargs["election_id"]),
100	}
101
102	def get_context_data(self, **kwargs):	1✔
103	context = super().get_context_data(**kwargs)	1✔
104	election = get_object_or_404(Election, slug=self.kwargs["election_id"])	1✔
105	context["election"] = election	1✔
106	return context	1✔
107
108	def form_valid(self, form):	1✔
109	ret = super().form_valid(form)	1✔
110	LoggedAction.objects.create(	1✔
111	user=self.request.user,
112	election=self.object.election,
113	action_type=ActionType.SOPN_UPLOAD,
114	ip_address=get_client_ip(self.request),
115	source=self.object.source_url,
116	edit_type=EditType.USER,
117	)
118	return ret	1✔
119
120
121	class ElectionSOPNMatchingView(GroupRequiredMixin, DetailView):	1✔
122	required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME	1✔
123	template_name = "official_documents/election_sopn_matcher.html"	1✔
124	queryset = (	1✔
125	Election.objects.all()
126	.select_related("electionsopn")
127	.prefetch_related("ballot_set")
128	)
129	slug_url_kwarg = "election_id"	1✔
130	slug_field = "slug"	1✔
131
132	def get_context_data(self, **kwargs):	1✔
133	context = super().get_context_data(**kwargs)	1✔
134
135	ballot_data = []	1✔
136	for ballot in self.object.ballot_set.all().order_by("post__label"):	1✔
137	ballot_for_matcher = {	1✔
138	"ballot_paper_id": ballot.ballot_paper_id,
139	"label": ballot.post.label,
140	}
141	if (	1!
142	self.object.electionsopn.pages_matched
143	and ballot.sopn.relevant_pages != "all"
144	):
NEW 145	ballot_for_matcher["matched"] = bool(ballot.sopn.relevant_pages)	×
NEW 146	ballot_for_matcher["matched_page"] = str(	×
147	ballot.sopn.first_page_int
148	)
149	ballot_data.append(ballot_for_matcher)	1✔
150
151	context["matcher_props"] = {	1✔
152	"election_id": self.object.name,
153	"sopn_pdf": self.object.electionsopn.uploaded_file.url,
154	"ballots": ballot_data,
155	}
156	return context	1✔
157
158	def post(self, request, election_id):	1✔
159	election = self.get_object()	1✔
160	splitter = ElectionSOPNPageSplitter(	1✔
161	election.electionsopn, json.loads(request.POST.get("matched_pages"))
162	)
163	splitter.split(method=PageMatchingMethods.MANUAL_MATCHED)	1✔
164	LoggedAction.objects.create(	1✔
165	user=request.user,
166	election=election,
167	action_type=ActionType.SOPN_SPLIT_BALLOTS,
168	ip_address=get_client_ip(request),
169	source="Manual matching",
170	edit_type=EditType.USER,
171	)
172	return HttpResponseRedirect(election.electionsopn.get_absolute_url())	1✔
173
174
175	class PostsForDocumentView(DetailView):	1✔
176	model = BallotSOPN	1✔
177	template_name = "official_documents/posts_for_document.html"	1✔
178
179	def get_context_data(self, **kwargs):	1✔
180	context = super().get_context_data(**kwargs)	1✔
181	documents = (	1✔
182	BallotSOPN.objects.filter(source_url=self.object.source_url)
183	.distinct("ballot__ballot_paper_id")
184	.filter(ballot__election=self.object.ballot.election)
185	.select_related("ballot__post", "ballot__election")
186	.order_by("ballot__ballot_paper_id")
187	.prefetch_related("ballot__suggestedpostlock_set")
188	)
189
190	context["document_posts"] = documents	1✔
191
192	return context	1✔
193
194
195	def get_add_from_document_cta_flash_message(document, remaining_posts):	1✔
196	return render_to_string(	1✔
197	"official_documents/_add_from_document_cta_flash_message.html",
198	{"document": document, "remaining_posts": remaining_posts},
199	)
200
201
202	class UnlockedWithDocumentsView(TemplateView):	1✔
203	template_name = "official_documents/unlocked_with_documents.html"	1✔
204
205	def get_context_data(self, **kwargs):	1✔
206	context = super().get_context_data(**kwargs)	1✔
207
208	SOPNs_qs = BallotSOPN.objects.filter(	1✔
209	ballot__election__current=True
210	).select_related("ballot__election", "ballot__post")
211
212	SOPNs_qs = SOPNs_qs.exclude(	1✔
213	ballot__post__in=SuggestedPostLock.objects.all().values(
214	"ballot__post"
215	)
216	)
217
218	context["unlocked_sopns"] = SOPNs_qs.filter(	1✔
219	ballot__candidates_locked=False
220	)
221
222	return context	1✔

DemocracyClub / yournextrepresentative / 86cabedc-d736-4dbd-b64d-b716fa281168

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