d519c42c-c8ae-4abb-b6fc-d5dc17117cd8

Committed 19 Mar 2024 12:27PM UTC coverage: 67.277% (+0.06%) from 67.215%

Build # d519c42c-c8ae-4abb-b6fc-d5dc17117cd8

Build Type

Pull #2264

circleci

Committed by

symroe

Commit Message

Allow switching between new and old parsers

Pull Request Pull Request #2264: Textract interface improvements

Run Details

1718 of 2907 branches covered (59.1%)

Branch coverage included in aggregate %.

20 of 22 new or added lines in 2 files covered. (90.91%)

13 existing lines in 1 file now uncovered.

6886 of 9882 relevant lines covered (69.68%)

0.7 hits per line

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

95.65

/ynr/apps/bulk_adding/views/sopns.py

from typing import Optional

from braces.views import LoginRequiredMixin
from bulk_adding import forms, helpers
from bulk_adding.forms import QuickAddSinglePersonForm
from bulk_adding.models import RawPeople
from candidates.models import Ballot, LoggedAction
from candidates.models.db import ActionType, EditType
from candidates.views.version_data import get_client_ip
from django.contrib import messages
from django.db import transaction
from django.db.models import F
from django.db.models.query import Prefetch
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.urls import reverse
from django.views.generic import FormView, RedirectView, TemplateView
from moderation_queue.models import SuggestedPostLock
from official_documents.models import OfficialDocument
from official_documents.views import get_add_from_document_cta_flash_message
from parties.models import Party
from people.models import Person

from ynr.settings import SOPNParsingBackends


class BulkAddSOPNRedirectView(RedirectView):
    def get_redirect_url(self, *args, **kwargs):
        ballot = Ballot.objects.get(ballot_paper_id=kwargs["ballot_paper_id"])
        return ballot.get_bulk_add_url()


def sort_tables(key):
    if isinstance(key, QuickAddSinglePersonForm):
        name = key.initial.get("name", None)
        value = "zzzzzzzzzz"
        if name:
            value = name.split(" ")[-1]
    if isinstance(key, Person):
        value = key.last_name_guess
    return (value is not None, value)


class BaseSOPNBulkAddView(LoginRequiredMixin, TemplateView):
    def get_ballot(self):
        """
        Get the ballot object with related objects prefetched where possible to
        help performance.
        """
        queryset = Ballot.objects.select_related(
            "post", "election", "rawpeople", "post__party_set"
        ).prefetch_related(
            "membership_set",
            "membership_set__person",
            "membership_set__person__other_names",
            "membership_set__party",
            "membership_set__party__descriptions",
            Prefetch(
                "officialdocument_set",
                queryset=OfficialDocument.objects.filter(
                    document_type=OfficialDocument.NOMINATION_PAPER
                ),
            ),
        )
        return get_object_or_404(
            queryset, ballot_paper_id=self.kwargs["ballot_paper_id"]
        )

    def add_election_and_post_to_context(self, context):
        if not hasattr(self, "ballot"):
            self.ballot = self.get_ballot()
        context["ballot"] = self.ballot
        context["post"] = self.ballot.post
        context["election_obj"] = self.ballot.election
        try:
            context["official_document"] = self.ballot.sopn
        except OfficialDocument.DoesNotExist:
            context["official_document"] = None
        self.official_document = context["official_document"]
        return context

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

        people_set = set()
        for membership in context["ballot"].membership_set.all():
            person = membership.person
            person.party = membership.party
            person.previous_party_affiliations = (
                membership.previous_party_affiliations.all()
            )

            people_set.add(person)

        known_people = list(people_set)
        known_people.sort(key=lambda i: i.last_name_guess)
        context["known_people"] = known_people
        return context

    def remaining_posts_for_sopn(self):
        return OfficialDocument.objects.filter(
            source_url=self.official_document.source_url,
            ballot__election=F("ballot__election"),
            ballot__suggestedpostlock=None,
        )

    def post(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        if context["formset"].is_valid():
            return self.form_valid(context)
        return self.form_invalid(context)


class BulkAddSOPNView(BaseSOPNBulkAddView):
    template_name = "bulk_add/sopns/add_form.html"

    def get(self, request, *args, **kwargs):
        if not request.GET.get("edit"):
            self.ballot = self.get_ballot()
            if (
                hasattr(self.ballot, "rawpeople")
                and self.ballot.rawpeople.is_trusted
            ):
                return HttpResponseRedirect(
                    self.ballot.get_bulk_add_review_url()
                )
        return super().get(request, *args, **kwargs)

    def get_active_parser(self) -> Optional[SOPNParsingBackends]:
        if self.request.GET.get("v1_parser"):
            return SOPNParsingBackends.CAMELOT
        if self.ballot.rawpeople.textract_data:
            return SOPNParsingBackends.TEXTRACT
        if self.ballot.rawpeople.data:
            return SOPNParsingBackends.CAMELOT
        return None

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

        form_kwargs = {"ballot": context["ballot"]}

        if hasattr(context["ballot"], "rawpeople"):
            context["active_parser"] = self.get_active_parser()

            form_kwargs.update(
                context["ballot"].rawpeople.as_form_kwargs(
                    parser=self.get_active_parser()
                )
            )
            context["has_parsed_people"] = (
                context["ballot"].rawpeople.source_type == "parsed_pdf"
            )

        if (
            "official_document" in context
            and context["official_document"] is not None
        ):
            form_kwargs["source"] = context["official_document"].source_url

        if self.request.POST:
            context["formset"] = forms.BulkAddFormSetFactory(
                self.request.POST, **form_kwargs
            )
        else:
            context["formset"] = forms.BulkAddFormSetFactory(**form_kwargs)

        tables = list(context["formset"]) + context["known_people"]
        sorted_tables = sorted(tables, key=sort_tables, reverse=False)
        sorted_with_type = []
        for table in sorted_tables:
            if isinstance(table, QuickAddSinglePersonForm):
                row = {
                    "template_name": "bulk_add/sopns/quick_add_form.html",
                    "data": table,
                }
            if isinstance(table, Person):
                row = {
                    "template_name": "bulk_add/sopns/existing_person_table.html",
                    "data": table,
                }
            sorted_with_type.append(row)
        context["sorted_with_type"] = sorted_with_type

        return context

    def form_valid(self, context):
        raw_ballot_data = []
        for form_data in context["formset"].cleaned_data:
            if not form_data or form_data.get("DELETE"):
                continue
            party_id = form_data["party"]["party_id"]
            description_id = form_data["party"]["description_id"]
            candidate_data = {
                "name": form_data["name"],
                "party_id": party_id,
                "description_id": description_id,
            }
            if form_data["previous_party_affiliations"]:
                candidate_data["previous_party_affiliations"] = form_data[
                    "previous_party_affiliations"
                ]

            raw_ballot_data.append(candidate_data)

        RawPeople.objects.update_or_create(
            ballot=context["ballot"],
            defaults={
                "data": raw_ballot_data,
                "source": context["official_document"].source_url[:512],
                "source_type": RawPeople.SOURCE_BULK_ADD_FORM,
            },
        )

        return HttpResponseRedirect(context["ballot"].get_bulk_add_review_url())

    def form_invalid(self, context):
        return self.render_to_response(context)


class BulkAddSOPNReviewView(BaseSOPNBulkAddView):
    template_name = "bulk_add/sopns/add_review_form.html"

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

        initial = []
        if hasattr(context["ballot"], "rawpeople"):
            raw_ballot_data = context["ballot"].rawpeople.data
        else:
            # Race condition! Someone else has processes this area
            # between page views. Best just show the data we have.
            raw_ballot_data = []

        for candidacy in raw_ballot_data:
            form = {}
            party = Party.objects.get(ec_id=candidacy["party_id"])

            form["party_description_text"] = party.name
            if candidacy.get("description_id"):
                party_description = party.descriptions.get(
                    pk=candidacy["description_id"]
                )
                form["party_description"] = party_description
                form["party_description_text"] = party_description.description

            form["name"] = candidacy["name"]
            form["party"] = party.ec_id
            form["source"] = context["official_document"].source_url

            if candidacy.get("previous_party_affiliations"):
                form["previous_party_affiliations"] = ",".join(
                    candidacy["previous_party_affiliations"]
                )

            initial.append(form)

        if self.request.POST:
            context["formset"] = forms.BulkAddReviewFormSet(
                self.request.POST, ballot=context["ballot"]
            )
        else:
            context["formset"] = forms.BulkAddReviewFormSet(
                initial=initial, ballot=context["ballot"]
            )
        return context

    def form_valid(self, context):
        with transaction.atomic():
            for person_form in context["formset"]:
                data = person_form.cleaned_data

                if data.get("select_person") == "_new":
                    # Add a new person
                    person = helpers.add_person(self.request, data)
                else:
                    person = Person.objects.get(pk=int(data["select_person"]))

                party = Party.objects.get(ec_id=data["party"])
                previous_party_affiliations = data.get(
                    "previous_party_affiliations", None
                )
                if previous_party_affiliations:
                    party_ids = data["previous_party_affiliations"].split(",")
                    previous_party_affiliations = Party.objects.filter(
                        ec_id__in=party_ids
                    )

                helpers.update_person(
                    request=self.request,
                    person=person,
                    party=party,
                    ballot=context["ballot"],
                    source=data["source"],
                    party_description=data["party_description"],
                    previous_party_affiliations=previous_party_affiliations,
                    data=data,
                )

            # ballot has changed so we should remove any out of date suggestions
            ballot = context["ballot"]
            ballot.delete_outdated_suggested_locks()

            SuggestedPostLock.objects.create(
                user=self.request.user, ballot=ballot
            )

            LoggedAction.objects.create(
                user=self.request.user,
                action_type=ActionType.SUGGEST_BALLOT_LOCK,
                ip_address=get_client_ip(self.request),
                ballot=ballot,
                source="Suggested after bulk adding",
                edit_type=EditType.BULK_ADD.name,
            )

            if hasattr(ballot, "rawpeople"):
                # Delete the raw import, as it's no longer useful
                ballot.rawpeople.delete()

        messages.add_message(
            self.request,
            messages.SUCCESS,
            get_add_from_document_cta_flash_message(
                self.official_document, self.remaining_posts_for_sopn()
            ),
            extra_tags="safe do-something-else",
        )

        remaining_qs = self.remaining_posts_for_sopn().exclude(
            pk=self.official_document.pk
        )
        if remaining_qs.exists():
            url = reverse(
                "posts_for_document", kwargs={"pk": self.official_document.pk}
            )
        else:
            url = context["ballot"].get_absolute_url()
        return HttpResponseRedirect(url)

    def form_invalid(self, context):
        return self.render_to_response(context)


class DeleteRawPeople(LoginRequiredMixin, FormView):
    """
    View to delete a RawPeople object for a ballot
    """

    form_class = forms.DeleteRawPeopleForm

    def form_valid(self, form):
        ballot = get_object_or_404(
            Ballot, ballot_paper_id=form.cleaned_data["ballot_paper_id"]
        )
        try:
            ballot.rawpeople.delete()
            LoggedAction.objects.create(
                user=self.request.user,
                ip_address=get_client_ip(self.request),
                action_type=ActionType.DELETED_PARSED_RAW_PEOPLE,
                ballot=ballot,
                edit_type=EditType.USER.name,
            )
        except RawPeople.DoesNotExist:
            pass

        return HttpResponseRedirect(ballot.get_bulk_add_url())

1	from typing import Optional	1✔
2
3	from braces.views import LoginRequiredMixin	1✔
4	from bulk_adding import forms, helpers	1✔
5	from bulk_adding.forms import QuickAddSinglePersonForm	1✔
6	from bulk_adding.models import RawPeople	1✔
7	from candidates.models import Ballot, LoggedAction	1✔
8	from candidates.models.db import ActionType, EditType	1✔
9	from candidates.views.version_data import get_client_ip	1✔
10	from django.contrib import messages	1✔
11	from django.db import transaction	1✔
12	from django.db.models import F	1✔
13	from django.db.models.query import Prefetch	1✔
14	from django.http import HttpResponseRedirect	1✔
15	from django.shortcuts import get_object_or_404	1✔
16	from django.urls import reverse	1✔
17	from django.views.generic import FormView, RedirectView, TemplateView	1✔
18	from moderation_queue.models import SuggestedPostLock	1✔
19	from official_documents.models import OfficialDocument	1✔
20	from official_documents.views import get_add_from_document_cta_flash_message	1✔
21	from parties.models import Party	1✔
22	from people.models import Person	1✔
23
24	from ynr.settings import SOPNParsingBackends	1✔
25
26
27	class BulkAddSOPNRedirectView(RedirectView):	1✔
28	def get_redirect_url(self, args, *kwargs):	1✔
29	ballot = Ballot.objects.get(ballot_paper_id=kwargs["ballot_paper_id"])	1✔
30	return ballot.get_bulk_add_url()	1✔
31
32
33	def sort_tables(key):	1✔
34	if isinstance(key, QuickAddSinglePersonForm):	1✔
35	name = key.initial.get("name", None)	1✔
36	value = "zzzzzzzzzz"	1✔
37	if name:	1✔
38	value = name.split(" ")[-1]	1✔
39	if isinstance(key, Person):	1✔
40	value = key.last_name_guess	1✔
41	return (value is not None, value)	1✔
42
43
44	class BaseSOPNBulkAddView(LoginRequiredMixin, TemplateView):	1✔
45	def get_ballot(self):	1✔
46	"""
47	Get the ballot object with related objects prefetched where possible to
48	help performance.
49	"""
50	queryset = Ballot.objects.select_related(	1✔
51	"post", "election", "rawpeople", "post__party_set"
52	).prefetch_related(
53	"membership_set",
54	"membership_set__person",
55	"membership_set__person__other_names",
56	"membership_set__party",
57	"membership_set__party__descriptions",
58	Prefetch(
59	"officialdocument_set",
60	queryset=OfficialDocument.objects.filter(
61	document_type=OfficialDocument.NOMINATION_PAPER
62	),
63	),
64	)
65	return get_object_or_404(	1✔
66	queryset, ballot_paper_id=self.kwargs["ballot_paper_id"]
67	)
68
69	def add_election_and_post_to_context(self, context):	1✔
70	if not hasattr(self, "ballot"):	1✔
71	self.ballot = self.get_ballot()	1✔
72	context["ballot"] = self.ballot	1✔
73	context["post"] = self.ballot.post	1✔
74	context["election_obj"] = self.ballot.election	1✔
75	try:	1✔
76	context["official_document"] = self.ballot.sopn	1✔
77	except OfficialDocument.DoesNotExist:	×
78	context["official_document"] = None	×
79	self.official_document = context["official_document"]	1✔
80	return context	1✔
81
82	def get_context_data(self, **kwargs):	1✔
83	context = super().get_context_data(**kwargs)	1✔
84	context.update(self.add_election_and_post_to_context(context))	1✔
85
86	people_set = set()	1✔
87	for membership in context["ballot"].membership_set.all():	1✔
88	person = membership.person	1✔
89	person.party = membership.party	1✔
90	person.previous_party_affiliations = (	1✔
91	membership.previous_party_affiliations.all()
92	)
93
94	people_set.add(person)	1✔
95
96	known_people = list(people_set)	1✔
97	known_people.sort(key=lambda i: i.last_name_guess)	1✔
98	context["known_people"] = known_people	1✔
99	return context	1✔
100
101	def remaining_posts_for_sopn(self):	1✔
102	return OfficialDocument.objects.filter(	1✔
103	source_url=self.official_document.source_url,
104	ballot__election=F("ballot__election"),
105	ballot__suggestedpostlock=None,
106	)
107
108	def post(self, request, args, *kwargs):	1✔
109	context = self.get_context_data(**kwargs)	1✔
110	if context["formset"].is_valid():	1✔
111	return self.form_valid(context)	1✔
112	return self.form_invalid(context)	1✔
113
114
115	class BulkAddSOPNView(BaseSOPNBulkAddView):	1✔
116	template_name = "bulk_add/sopns/add_form.html"	1✔
117
118	def get(self, request, args, *kwargs):	1✔
119	if not request.GET.get("edit"):	1✔
120	self.ballot = self.get_ballot()	1✔
121	if (	1✔
122	hasattr(self.ballot, "rawpeople")
123	and self.ballot.rawpeople.is_trusted
124	):
125	return HttpResponseRedirect(	1✔
126	self.ballot.get_bulk_add_review_url()
127	)
128	return super().get(request, args, *kwargs)	1✔
129
130	def get_active_parser(self) -> Optional[SOPNParsingBackends]:	1✔
131	if self.request.GET.get("v1_parser"):	1✔
132	return SOPNParsingBackends.CAMELOT	1✔
133	if self.ballot.rawpeople.textract_data:	1✔
134	return SOPNParsingBackends.TEXTRACT	1✔
135	if self.ballot.rawpeople.data:	1!
136	return SOPNParsingBackends.CAMELOT	1✔
NEW 137	return None	×
138
139	def get_context_data(self, **kwargs):	1✔
140	context = super().get_context_data(**kwargs)	1✔
141
142	form_kwargs = {"ballot": context["ballot"]}	1✔
143
144	if hasattr(context["ballot"], "rawpeople"):	1✔
145	context["active_parser"] = self.get_active_parser()	1✔
146
147	form_kwargs.update(	1✔
148	context["ballot"].rawpeople.as_form_kwargs(
149	parser=self.get_active_parser()
150	)
151	)
152	context["has_parsed_people"] = (	1✔
153	context["ballot"].rawpeople.source_type == "parsed_pdf"
154	)
155
156	if (	1✔
157	"official_document" in context
158	and context["official_document"] is not None
159	):
160	form_kwargs["source"] = context["official_document"].source_url	1✔
161
162	if self.request.POST:	1✔
163	context["formset"] = forms.BulkAddFormSetFactory(	1✔
164	self.request.POST, **form_kwargs
165	)
166	else:
167	context["formset"] = forms.BulkAddFormSetFactory(**form_kwargs)	1✔
168
169	tables = list(context["formset"]) + context["known_people"]	1✔
170	sorted_tables = sorted(tables, key=sort_tables, reverse=False)	1✔
171	sorted_with_type = []	1✔
172	for table in sorted_tables:	1✔
173	if isinstance(table, QuickAddSinglePersonForm):	1✔
174	row = {	1✔
175	"template_name": "bulk_add/sopns/quick_add_form.html",
176	"data": table,
177	}
178	if isinstance(table, Person):	1✔
179	row = {	1✔
180	"template_name": "bulk_add/sopns/existing_person_table.html",
181	"data": table,
182	}
183	sorted_with_type.append(row)	1✔
184	context["sorted_with_type"] = sorted_with_type	1✔
185
186	return context	1✔
187
188	def form_valid(self, context):	1✔
189	raw_ballot_data = []	1✔
190	for form_data in context["formset"].cleaned_data:	1✔
191	if not form_data or form_data.get("DELETE"):	1!
192	continue	×
193	party_id = form_data["party"]["party_id"]	1✔
194	description_id = form_data["party"]["description_id"]	1✔
195	candidate_data = {	1✔
196	"name": form_data["name"],
197	"party_id": party_id,
198	"description_id": description_id,
199	}
200	if form_data["previous_party_affiliations"]:	1✔
201	candidate_data["previous_party_affiliations"] = form_data[	1✔
202	"previous_party_affiliations"
203	]
204
205	raw_ballot_data.append(candidate_data)	1✔
206
207	RawPeople.objects.update_or_create(	1✔
208	ballot=context["ballot"],
209	defaults={
210	"data": raw_ballot_data,
211	"source": context["official_document"].source_url[:512],
212	"source_type": RawPeople.SOURCE_BULK_ADD_FORM,
213	},
214	)
215
216	return HttpResponseRedirect(context["ballot"].get_bulk_add_review_url())	1✔
217
218	def form_invalid(self, context):	1✔
219	return self.render_to_response(context)	1✔
220
221
222	class BulkAddSOPNReviewView(BaseSOPNBulkAddView):	1✔
223	template_name = "bulk_add/sopns/add_review_form.html"	1✔
224
225	def get_context_data(self, **kwargs):	1✔
226	context = super().get_context_data(**kwargs)	1✔
227
228	initial = []	1✔
229	if hasattr(context["ballot"], "rawpeople"):	1!
230	raw_ballot_data = context["ballot"].rawpeople.data	1✔
231	else:
232	# Race condition! Someone else has processes this area
233	# between page views. Best just show the data we have.
234	raw_ballot_data = []	×
235
236	for candidacy in raw_ballot_data:	1✔
237	form = {}	1✔
238	party = Party.objects.get(ec_id=candidacy["party_id"])	1✔
239
240	form["party_description_text"] = party.name	1✔
241	if candidacy.get("description_id"):	1✔
242	party_description = party.descriptions.get(	1✔
243	pk=candidacy["description_id"]
244	)
245	form["party_description"] = party_description	1✔
246	form["party_description_text"] = party_description.description	1✔
247
248	form["name"] = candidacy["name"]	1✔
249	form["party"] = party.ec_id	1✔
250	form["source"] = context["official_document"].source_url	1✔
251
252	if candidacy.get("previous_party_affiliations"):	1✔
253	form["previous_party_affiliations"] = ",".join(	1✔
254	candidacy["previous_party_affiliations"]
255	)
256
257	initial.append(form)	1✔
258
259	if self.request.POST:	1✔
260	context["formset"] = forms.BulkAddReviewFormSet(	1✔
261	self.request.POST, ballot=context["ballot"]
262	)
263	else:
264	context["formset"] = forms.BulkAddReviewFormSet(	1✔
265	initial=initial, ballot=context["ballot"]
266	)
267	return context	1✔
268
269	def form_valid(self, context):	1✔
270	with transaction.atomic():	1✔
271	for person_form in context["formset"]:	1✔
272	data = person_form.cleaned_data	1✔
273
274	if data.get("select_person") == "_new":	1✔
275	# Add a new person
276	person = helpers.add_person(self.request, data)	1✔
277	else:
278	person = Person.objects.get(pk=int(data["select_person"]))	1✔
279
280	party = Party.objects.get(ec_id=data["party"])	1✔
281	previous_party_affiliations = data.get(	1✔
282	"previous_party_affiliations", None
283	)
284	if previous_party_affiliations:	1✔
285	party_ids = data["previous_party_affiliations"].split(",")	1✔
286	previous_party_affiliations = Party.objects.filter(	1✔
287	ec_id__in=party_ids
288	)
289
290	helpers.update_person(	1✔
291	request=self.request,
292	person=person,
293	party=party,
294	ballot=context["ballot"],
295	source=data["source"],
296	party_description=data["party_description"],
297	previous_party_affiliations=previous_party_affiliations,
298	data=data,
299	)
300
301	# ballot has changed so we should remove any out of date suggestions
302	ballot = context["ballot"]	1✔
303	ballot.delete_outdated_suggested_locks()	1✔
304
305	SuggestedPostLock.objects.create(	1✔
306	user=self.request.user, ballot=ballot
307	)
308
309	LoggedAction.objects.create(	1✔
310	user=self.request.user,
311	action_type=ActionType.SUGGEST_BALLOT_LOCK,
312	ip_address=get_client_ip(self.request),
313	ballot=ballot,
314	source="Suggested after bulk adding",
315	edit_type=EditType.BULK_ADD.name,
316	)
317
318	if hasattr(ballot, "rawpeople"):	1!
319	# Delete the raw import, as it's no longer useful
320	ballot.rawpeople.delete()	1✔
321
322	messages.add_message(	1✔
323	self.request,
324	messages.SUCCESS,
325	get_add_from_document_cta_flash_message(
326	self.official_document, self.remaining_posts_for_sopn()
327	),
328	extra_tags="safe do-something-else",
329	)
330
331	remaining_qs = self.remaining_posts_for_sopn().exclude(	1✔
332	pk=self.official_document.pk
333	)
334	if remaining_qs.exists():	1✔
335	url = reverse(	1✔
336	"posts_for_document", kwargs={"pk": self.official_document.pk}
337	)
338	else:
339	url = context["ballot"].get_absolute_url()	1✔
340	return HttpResponseRedirect(url)	1✔
341
342	def form_invalid(self, context):	1✔
343	return self.render_to_response(context)	1✔
344
345
346	class DeleteRawPeople(LoginRequiredMixin, FormView):	1✔
347	"""
348	View to delete a RawPeople object for a ballot
349	"""
350
351	form_class = forms.DeleteRawPeopleForm	1✔
352
353	def form_valid(self, form):	1✔
354	ballot = get_object_or_404(	1✔
355	Ballot, ballot_paper_id=form.cleaned_data["ballot_paper_id"]
356	)
357	try:	1✔
358	ballot.rawpeople.delete()	1✔
359	LoggedAction.objects.create(	1✔
360	user=self.request.user,
361	ip_address=get_client_ip(self.request),
362	action_type=ActionType.DELETED_PARSED_RAW_PEOPLE,
363	ballot=ballot,
364	edit_type=EditType.USER.name,
365	)
366	except RawPeople.DoesNotExist:	×
367	pass	×
368
369	return HttpResponseRedirect(ballot.get_bulk_add_url())	1✔

DemocracyClub / yournextrepresentative / d519c42c-c8ae-4abb-b6fc-d5dc17117cd8

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