9a9da2c9-a605-44fb-838b-847101450da2

Committed 28 Mar 2024 11:19AM UTC coverage: 67.282% (+0.07%) from 67.215%

Build # 9a9da2c9-a605-44fb-838b-847101450da2

Build Type

Pull #2264

circleci

Committed by

symroe

Commit Message

Save images when getting results not when starting job

This is partly to speed up uploads from users who are getting timeouts
waiting for the slow server to take the images in real time

Pull Request Pull Request #2264: Textract interface improvements

Run Details

1718 of 2907 branches covered (59.1%)

Branch coverage included in aggregate %.

25 of 30 new or added lines in 3 files covered. (83.33%)

4 existing lines in 2 files now uncovered.

6888 of 9884 relevant lines covered (69.69%)

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 / 9a9da2c9-a605-44fb-838b-847101450da2

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