86dd6b3e-ec4d-4a7f-87fd-9e5e4c5acf92

Committed 02 Apr 2024 09:21PM UTC coverage: 68.208% (+0.9%) from 67.282%

Build # 86dd6b3e-ec4d-4a7f-87fd-9e5e4c5acf92

Build Type

Pull #2269

circleci

Committed by

symroe

Commit Message

Allow BallotSOPNs to be images

Pull Request Pull Request #2269: Redesign SOPN models

Run Details

1734 of 2910 branches covered (59.59%)

Branch coverage included in aggregate %.

377 of 439 new or added lines in 21 files covered. (85.88%)

27 existing lines in 5 files now uncovered.

7060 of 9983 relevant lines covered (70.72%)

0.71 hits per line

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

92.93

/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
from elections.models import Election
from moderation_queue.models import SuggestedPostLock
from sopn_parsing.helpers.pdf_helpers import ElectionSOPNPageSplitter
from sopn_parsing.helpers.text_helpers import NoTextInDocumentError

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


class CreateBallotSOPNView(GroupRequiredMixin, CreateView):
    required_group_name = DOCUMENT_UPLOADERS_GROUP_NAME

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

    def get_initial(self):
        return {
            "ballot": Ballot.objects.get(
                ballot_paper_id=self.kwargs["ballot_paper_id"]
            ),
        }

    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,
        )

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

DemocracyClub / yournextrepresentative / 86dd6b3e-ec4d-4a7f-87fd-9e5e4c5acf92

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