6bb82f13-6848-4ec6-8bcf-80b08b2760de

Committed 27 Jun 2024 03:30PM UTC coverage: 67.699% (-0.2%) from 67.857%

Build # 6bb82f13-6848-4ec6-8bcf-80b08b2760de

Build Type

Pull #2386

circleci

Committed by

VirginiaDooley

Commit Message

Record new version with photo upload

Pull Request Pull Request #2386: WIP record new version with photo upload

Run Details

1540 of 2797 branches covered (55.06%)

Branch coverage included in aggregate %.

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

51 existing lines in 2 files now uncovered.

7376 of 10373 relevant lines covered (71.11%)

0.71 hits per line

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

83.52

/ynr/apps/moderation_queue/views.py

import random
import re
from typing import Any, Dict
from urllib.parse import quote

import bleach
from auth_helpers.views import GroupRequiredMixin
from braces.views import LoginRequiredMixin
from candidates.models import TRUSTED_TO_LOCK_GROUP_NAME, Ballot, LoggedAction
from candidates.models.db import ActionType
from candidates.views.version_data import get_client_ip
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.core.paginator import Paginator
from django.db import models
from django.db.models import Count, Q
from django.http import (
    HttpResponseBadRequest,
    HttpResponseRedirect,
    JsonResponse,
)
from django.shortcuts import get_object_or_404
from django.urls import reverse
from django.views.generic import CreateView, ListView, TemplateView, View
from elections.models import Election
from moderation_queue.filters import QueuedImageFilter
from moderation_queue.helpers import (
    ImageDownloadException,
    download_image_from_url,
    image_form_valid_response,
    upload_photo_response,
)
from people.models import TRUSTED_TO_EDIT_NAME, Person
from popolo.models import Membership, OtherName

from .forms import (
    PhotoReviewForm,
    PhotoRotateForm,
    SuggestedPostLockForm,
    UploadPersonPhotoImageForm,
    UploadPersonPhotoURLForm,
)
from .models import PHOTO_REVIEWERS_GROUP_NAME, QueuedImage, SuggestedPostLock


@login_required
def upload_photo(request, person_id):
    person = get_object_or_404(Person, id=person_id)
    image_form = UploadPersonPhotoImageForm(initial={"person": person})
    url_form = UploadPersonPhotoURLForm(initial={"person": person})
    return upload_photo_response(request, person, image_form, url_form)


@login_required
def upload_photo_image(request, person_id):
    person = get_object_or_404(Person, id=person_id)
    image_form = UploadPersonPhotoImageForm(request.POST, request.FILES)
    url_form = UploadPersonPhotoURLForm(initial={"person": person})
    if image_form.is_valid():
        return image_form_valid_response(
            request=request, person=person, image_form=image_form
        )
    return upload_photo_response(
        request=request, person=person, image_form=image_form, url_form=url_form
    )


@login_required
def upload_photo_url(request, person_id):
    person = get_object_or_404(Person, id=person_id)
    image_form = UploadPersonPhotoImageForm(initial={"person": person})
    url_form = UploadPersonPhotoURLForm(request.POST)

    if not url_form.is_valid():
        return upload_photo_response(
            request=request,
            person=person,
            image_form=image_form,
            url_form=url_form,
        )

    image_url = url_form.cleaned_data["image_url"]
    try:
        image_bytes = download_image_from_url(image_url)
    except ImageDownloadException as ide:
        return HttpResponseBadRequest(str(ide).encode("utf-8"))

    filename = image_url.split("/")[-1]
    extension = filename.split(".")[-1]
    filename = filename.replace(extension, "png")
    queued_image = QueuedImage(
        why_allowed=url_form.cleaned_data["why_allowed_url"],
        justification_for_use=url_form.cleaned_data[
            "justification_for_use_url"
        ],
        person=person,
        user=request.user,
    )
    queued_image.image.save(filename, image_bytes, save=True)
    LoggedAction.objects.create(
        user=request.user,
        action_type=ActionType.PHOTO_UPLOAD,
        ip_address=get_client_ip(request),
        popit_person_new_version="",
        person=person,
        source=url_form.cleaned_data["justification_for_use_url"],
    )
    return HttpResponseRedirect(
        reverse("photo-upload-success", kwargs={"person_id": person.id})
    )


class PhotoUploadSuccess(TemplateView):
    template_name = "moderation_queue/photo-upload-success.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["person"] = Person.objects.get(id=kwargs["person_id"])
        return context


class PhotoReviewList(GroupRequiredMixin, ListView):
    template_name = "moderation_queue/photo-review-list.html"
    required_group_name = PHOTO_REVIEWERS_GROUP_NAME

    def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
        context = super().get_context_data(**kwargs)
        filter_obj = QueuedImageFilter(
            data=self.request.GET,
            queryset=context["object_list"],
            request=self.request,
        )
        context["filter_obj"] = filter_obj
        context["object_list"] = Paginator(filter_obj.qs, 20).page(1)
        context["shortcuts"] = filter_obj.shortcuts

        return context

    def get_queryset(self):
        return (
            QueuedImage.objects.filter(decision="undecided")
            .order_by("created")
            .select_related("user", "person")
        )


def tidy_party_name(name):
    """If a party name contains an initialism in brackets, use that instead

    >>> tidy_party_name('Hello World Party (HWP)') == 'HWP'
    True
    >>> tidy_party_name('Hello World Party') == 'Hello World Party'
    True
    """
    m = re.search(r"\(([A-Z]+)\)", name)
    if m:
        return m.group(1)
    return name


def value_if_none(v, default):
    return default if v is None else v


class PhotoReview(GroupRequiredMixin, TemplateView):
    """The class-based view for approving or rejecting a particular photo"""

    template_name = "moderation_queue/photo-review.html"
    http_method_names = ["get", "post"]
    required_group_name = PHOTO_REVIEWERS_GROUP_NAME

    def get_google_image_search_url(self, person):
        image_search_query = '"{}"'.format(person.name)
        last_candidacy = person.last_candidacy
        if last_candidacy:
            party = last_candidacy.party
            if party:
                image_search_query += ' "{}"'.format(
                    tidy_party_name(party.name)
                )
            post = last_candidacy.ballot.post
            if post is not None:
                image_search_query += ' "{}"'.format(post.label)
        return "https://www.google.co.uk/search?tbm=isch&q={}".format(
            quote(image_search_query)
        )

    def get_google_reverse_image_search_url(self, image_url):
        url = "https://www.google.com/searchbyimage?&image_url="
        absolute_image_url = self.request.build_absolute_uri(image_url)
        return url + quote(absolute_image_url)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        self.queued_image = get_object_or_404(
            QueuedImage, pk=kwargs["queued_image_id"]
        )
        context["queued_image"] = self.queued_image
        if context["queued_image"].user:
            username = context["queued_image"].user.username
            email = context["queued_image"].user.email
        else:
            username = "a robot 🤖"
            email = None
        context["username"] = username
        context["email"] = email
        person = Person.objects.get(id=self.queued_image.person.id)
        context["has_crop_bounds"] = int(self.queued_image.has_crop_bounds)
        max_x = self.queued_image.image.width - 1
        max_y = self.queued_image.image.height - 1
        guessed_crop_bounds = [
            value_if_none(self.queued_image.crop_min_x, 0),
            value_if_none(self.queued_image.crop_min_y, 0),
            value_if_none(self.queued_image.crop_max_x, max_x),
            value_if_none(self.queued_image.crop_max_y, max_y),
        ]
        context["form"] = PhotoReviewForm(
            queued_image=self.queued_image,
            request=self.request,
            initial={
                "queued_image_id": self.queued_image.id,
                "decision": self.queued_image.decision,
                "x_min": guessed_crop_bounds[0],
                "y_min": guessed_crop_bounds[1],
                "x_max": guessed_crop_bounds[2],
                "y_max": guessed_crop_bounds[3],
                "moderator_why_allowed": self.queued_image.why_allowed,
            },
        )
        context["guessed_crop_bounds"] = guessed_crop_bounds
        context["why_allowed"] = self.queued_image.why_allowed
        context["moderator_why_allowed"] = self.queued_image.why_allowed
        # There are often source links supplied in the justification,
        # and it's convenient to be able to follow them. However, make
        # sure that any maliciously added HTML tags have been stripped
        # before linkifying any URLs:
        context["justification_for_use"] = bleach.linkify(
            bleach.clean(
                self.queued_image.justification_for_use, tags=[], strip=True
            )
        )
        context["google_image_search_url"] = self.get_google_image_search_url(
            person
        )
        context[
            "google_reverse_image_search_url"
        ] = self.get_google_reverse_image_search_url(
            self.queued_image.image.url
        )
        context["person"] = person
        return context

    def form_valid(self, form):
        self.queued_image = self.form.process()
        if isinstance(form, PhotoReviewForm):
            candidate_link = f'<a href="{self.queued_image.person.get_absolute_url()}">{self.queued_image.person.name}</a>'
            message_mapping = {
                QueuedImage.APPROVED: f"You approved a photo upload for {candidate_link}",
                QueuedImage.REJECTED: f"You rejected a photo upload for {candidate_link}",
                QueuedImage.IGNORE: f"You left a photo upload for {candidate_link} in the queue",
                QueuedImage.UNDECIDED: f"You indicated a photo upload for {candidate_link} should be ignored",
            }
            level_mapping = {QueuedImage.APPROVED: messages.SUCCESS}
            message = message_mapping.get(self.queued_image.decision)
            level = level_mapping.get(self.queued_image.decision, messages.INFO)
            messages.add_message(
                self.request, level, message, extra_tags="safe photo-review"
            )
            return HttpResponseRedirect(reverse("photo-review-list"))
        return HttpResponseRedirect(
            reverse(
                "photo-review",
                kwargs={"queued_image_id": self.queued_image.id},
            )
        )

    def form_invalid(self, form):
        return self.render_to_response(self.get_context_data(form=form))

    def post(self, request, *args, **kwargs):
        self.queued_image = QueuedImage.objects.get(
            pk=kwargs["queued_image_id"]
        )
        if "rotate" in request.POST:
            self.form = PhotoRotateForm(
                data=self.request.POST,
                request=request,
                queued_image=self.queued_image,
            )
        else:
            self.form = PhotoReviewForm(
                data=self.request.POST,
                request=request,
                queued_image=self.queued_image,
            )
        if self.form.is_valid():
            return self.form_valid(self.form)
        return self.form_invalid(self.form)


class SuggestLockView(LoginRequiredMixin, CreateView):
    """This handles creating a SuggestedPostLock from a form submission"""

    model = SuggestedPostLock
    form_class = SuggestedPostLockForm

    def form_invalid(self, form):
        messages.add_message(
            request=self.request,
            level=messages.ERROR,
            message="Cannot add a lock suggestion because candidates are already locked",
            extra_tags="ballot-changed",
        )
        return HttpResponseRedirect(form.instance.ballot.get_absolute_url())

    def form_valid(self, form):
        user = self.request.user
        form.instance.user = user

        LoggedAction.objects.create(
            user=self.request.user,
            action_type=ActionType.SUGGEST_BALLOT_LOCK,
            ballot=form.cleaned_data["ballot"],
            ip_address=get_client_ip(self.request),
            source=form.cleaned_data["justification"],
        )

        messages.add_message(
            self.request,
            messages.SUCCESS,
            message="Thanks for suggesting we lock an area!",
            extra_tags="ballot-changed",
        )

        return super().form_valid(form)

    def get_success_url(self):
        return self.object.ballot.get_absolute_url()


class SuggestLockReviewListView(
    GroupRequiredMixin, LoginRequiredMixin, TemplateView
):
    """
    This is the view which lists all post lock suggestions that need review

    Most people will get to this by clicking on the red highlighted 'Post lock
    suggestions' counter in the header.
    """

    template_name = "moderation_queue/suggestedpostlock_review.html"
    required_group_name = TRUSTED_TO_LOCK_GROUP_NAME

    def get_random_election(self):
        """
        Get a random Election which has ballots with lock suggestions not
        belonging to the user.
        """
        # using annotate and order_by('?') produces strange results
        # see https://code.djangoproject.com/ticket/26390
        # so first do the annotation and filtering
        num_lock_suggestions = Count(
            "ballot",
            filter=Q(ballot__suggestedpostlock__isnull=False)
            & ~Q(ballot__suggestedpostlock__user=self.request.user),
        )
        elections = Election.objects.annotate(
            num_lock_suggestions=num_lock_suggestions
        ).filter(num_lock_suggestions__gte=1)
        # then use that QS to get the QS to randomise and return an object
        return Election.objects.filter(pk__in=elections).order_by("?").first()

    def get_lock_suggestions(self):
        """
        Return a QuerySet of Ballot objects with lock suggestions unrelated to
        the user in the request.
        """
        return (
            Ballot.objects.exclude(candidates_locked=True)
            .exclude(
                Q(suggestedpostlock__isnull=True)
                | Q(suggestedpostlock__user=self.request.user)
            )
            .select_related("election", "post")
            .prefetch_related(
                "officialdocument_set",
                models.Prefetch(
                    "suggestedpostlock_set",
                    SuggestedPostLock.objects.select_related("user"),
                ),
                models.Prefetch(
                    "membership_set",
                    Membership.objects.select_related(
                        "person", "party"
                    ).prefetch_related(
                        "person__other_names", "previous_party_affiliations"
                    ),
                ),
            )
        )

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        ballots = self.get_lock_suggestions()
        election = self.get_random_election()
        context["total_ballots"] = ballots.count()
        context["ballots"] = ballots.filter(election=election)[:10]
        return context


class SOPNReviewRequiredView(ListView):
    """List all post that have a nominations paper, but no lock suggestion"""

    template_name = "moderation_queue/sopn-review-required.html"

    def get(self, *args, **kwargs):
        if "random" in self.request.GET:
            qs = self.get_queryset()
            count = qs.count()
            if count:
                random_offset = random.randrange(count)
                ballot = qs[random_offset]
                url = ballot.get_bulk_add_url()
                return HttpResponseRedirect(url)
        return super().get(*args, **kwargs)

    def get_queryset(self):
        """
        Ballot objects with a document but no lock suggestion
        """
        return (
            Ballot.objects.filter(
                suggestedpostlock__isnull=True,
                candidates_locked=False,
                election__current=True,
            )
            .exclude(sopn=None)
            .select_related("post", "election", "sopn")
            .order_by("election", "post__label")
        )


class PersonNameCleanupView(TemplateView):
    template_name = "moderation_queue/person_name_cleanup.html"

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

        people = Person.objects.all().only("name")

        regex = re.compile("[A-Z][A-Z]+")
        context["two_upper"] = [p for p in people if regex.search(p.name)]

        return context


class PersonNameEditReviewListView(GroupRequiredMixin, ListView):
    http_method_names = ["get", "post"]
    template_name = "moderation_queue/person_name_review.html"
    required_group_name = TRUSTED_TO_EDIT_NAME
    model = OtherName

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        object_list = OtherName.objects.filter(needs_review=True)
        context = super().get_context_data(**kwargs)
        context["object_list"] = object_list

        return context

    def post(self, request, **kwargs):
        other_name = OtherName.objects.get(pk=request.POST.get("other_name_pk"))

        if "decision_approve" in request.POST:
            self.approve_name_change(other_name)
        elif "decision_reject" in request.POST:
            self.reject_name_change(other_name)
        elif "decision_delete" in request.POST:
            self.delete_name_change(other_name)

        else:
            raise ValueError("Invalid decision")
        return HttpResponseRedirect(reverse("person-name-review"))

    def approve_name_change(self, other_name):
        person = other_name.content_object
        person.edit_name(other_name.name, person.name, user=self.request.user)
        person.save()

    def delete_name_change(self, other_name):
        other_name.delete()

    def reject_name_change(self, other_name):
        other_name.needs_review = False
        other_name.save()


class RemoveSuggestedLocksView(LoginRequiredMixin, GroupRequiredMixin, View):
    required_group_name = TRUSTED_TO_LOCK_GROUP_NAME

    def post(self, request, *args, **kwargs):
        ballot = Ballot.objects.get(ballot_paper_id=request.POST["ballot"])
        ballot.suggestedpostlock_set.all().delete()
        if request.headers.get("x-requested-with") == "XMLHttpRequest":
            return JsonResponse({"removed": True})
        return HttpResponseRedirect(ballot.get_absolute_url())

1	import random	1✔
2	import re	1✔
3	from typing import Any, Dict	1✔
4	from urllib.parse import quote	1✔
5
6	import bleach	1✔
7	from auth_helpers.views import GroupRequiredMixin	1✔
8	from braces.views import LoginRequiredMixin	1✔
9	from candidates.models import TRUSTED_TO_LOCK_GROUP_NAME, Ballot, LoggedAction	1✔
10	from candidates.models.db import ActionType	1✔
11	from candidates.views.version_data import get_client_ip	1✔
12	from django.contrib import messages	1✔
13	from django.contrib.auth.decorators import login_required	1✔
14	from django.core.paginator import Paginator	1✔
15	from django.db import models	1✔
16	from django.db.models import Count, Q	1✔
17	from django.http import (	1✔
18	HttpResponseBadRequest,
19	HttpResponseRedirect,
20	JsonResponse,
21	)
22	from django.shortcuts import get_object_or_404	1✔
23	from django.urls import reverse	1✔
24	from django.views.generic import CreateView, ListView, TemplateView, View	1✔
25	from elections.models import Election	1✔
26	from moderation_queue.filters import QueuedImageFilter	1✔
27	from moderation_queue.helpers import (	1✔
28	ImageDownloadException,
29	download_image_from_url,
30	image_form_valid_response,
31	upload_photo_response,
32	)
33	from people.models import TRUSTED_TO_EDIT_NAME, Person	1✔
34	from popolo.models import Membership, OtherName	1✔
35
36	from .forms import (	1✔
37	PhotoReviewForm,
38	PhotoRotateForm,
39	SuggestedPostLockForm,
40	UploadPersonPhotoImageForm,
41	UploadPersonPhotoURLForm,
42	)
43	from .models import PHOTO_REVIEWERS_GROUP_NAME, QueuedImage, SuggestedPostLock	1✔
44
45
46	@login_required	1✔
47	def upload_photo(request, person_id):	1✔
48	person = get_object_or_404(Person, id=person_id)	1✔
49	image_form = UploadPersonPhotoImageForm(initial={"person": person})	1✔
50	url_form = UploadPersonPhotoURLForm(initial={"person": person})	1✔
51	return upload_photo_response(request, person, image_form, url_form)	1✔
52
53
54	@login_required	1✔
55	def upload_photo_image(request, person_id):	1✔
56	person = get_object_or_404(Person, id=person_id)	1✔
57	image_form = UploadPersonPhotoImageForm(request.POST, request.FILES)	1✔
58	url_form = UploadPersonPhotoURLForm(initial={"person": person})	1✔
59	if image_form.is_valid():	1!
60	return image_form_valid_response(	1✔
61	request=request, person=person, image_form=image_form
62	)
UNCOV 63	return upload_photo_response(	×
64	request=request, person=person, image_form=image_form, url_form=url_form
65	)
66
67
68	@login_required	1✔
69	def upload_photo_url(request, person_id):	1✔
70	person = get_object_or_404(Person, id=person_id)	1✔
71	image_form = UploadPersonPhotoImageForm(initial={"person": person})	1✔
72	url_form = UploadPersonPhotoURLForm(request.POST)	1✔
73
74	if not url_form.is_valid():	1✔
75	return upload_photo_response(	1✔
76	request=request,
77	person=person,
78	image_form=image_form,
79	url_form=url_form,
80	)
81
82	image_url = url_form.cleaned_data["image_url"]	1✔
83	try:	1✔
84	image_bytes = download_image_from_url(image_url)	1✔
UNCOV 85	except ImageDownloadException as ide:	×
UNCOV 86	return HttpResponseBadRequest(str(ide).encode("utf-8"))	×
87
88	filename = image_url.split("/")[-1]	1✔
89	extension = filename.split(".")[-1]	1✔
90	filename = filename.replace(extension, "png")	1✔
91	queued_image = QueuedImage(	1✔
92	why_allowed=url_form.cleaned_data["why_allowed_url"],
93	justification_for_use=url_form.cleaned_data[
94	"justification_for_use_url"
95	],
96	person=person,
97	user=request.user,
98	)
99	queued_image.image.save(filename, image_bytes, save=True)	1✔
100	LoggedAction.objects.create(	1✔
101	user=request.user,
102	action_type=ActionType.PHOTO_UPLOAD,
103	ip_address=get_client_ip(request),
104	popit_person_new_version="",
105	person=person,
106	source=url_form.cleaned_data["justification_for_use_url"],
107	)
108	return HttpResponseRedirect(	1✔
109	reverse("photo-upload-success", kwargs={"person_id": person.id})
110	)
111
112
113	class PhotoUploadSuccess(TemplateView):	1✔
114	template_name = "moderation_queue/photo-upload-success.html"	1✔
115
116	def get_context_data(self, **kwargs):	1✔
UNCOV 117	context = super().get_context_data(**kwargs)	×
UNCOV 118	context["person"] = Person.objects.get(id=kwargs["person_id"])	×
UNCOV 119	return context	×
120
121
122	class PhotoReviewList(GroupRequiredMixin, ListView):	1✔
123	template_name = "moderation_queue/photo-review-list.html"	1✔
124	required_group_name = PHOTO_REVIEWERS_GROUP_NAME	1✔
125
126	def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:	1✔
127	context = super().get_context_data(**kwargs)	1✔
128	filter_obj = QueuedImageFilter(	1✔
129	data=self.request.GET,
130	queryset=context["object_list"],
131	request=self.request,
132	)
133	context["filter_obj"] = filter_obj	1✔
134	context["object_list"] = Paginator(filter_obj.qs, 20).page(1)	1✔
135	context["shortcuts"] = filter_obj.shortcuts	1✔
136
137	return context	1✔
138
139	def get_queryset(self):	1✔
140	return (	1✔
141	QueuedImage.objects.filter(decision="undecided")
142	.order_by("created")
143	.select_related("user", "person")
144	)
145
146
147	def tidy_party_name(name):	1✔
148	"""If a party name contains an initialism in brackets, use that instead
149
150	>>> tidy_party_name('Hello World Party (HWP)') == 'HWP'
151	True
152	>>> tidy_party_name('Hello World Party') == 'Hello World Party'
153	True
154	"""
155	m = re.search(r"\(([A-Z]+)\)", name)	1✔
156	if m:	1!
UNCOV 157	return m.group(1)	×
158	return name	1✔
159
160
161	def value_if_none(v, default):	1✔
162	return default if v is None else v	1✔
163
164
165	class PhotoReview(GroupRequiredMixin, TemplateView):	1✔
166	"""The class-based view for approving or rejecting a particular photo"""
167
168	template_name = "moderation_queue/photo-review.html"	1✔
169	http_method_names = ["get", "post"]	1✔
170	required_group_name = PHOTO_REVIEWERS_GROUP_NAME	1✔
171
172	def get_google_image_search_url(self, person):	1✔
173	image_search_query = '"{}"'.format(person.name)	1✔
174	last_candidacy = person.last_candidacy	1✔
175	if last_candidacy:	1!
176	party = last_candidacy.party	1✔
177	if party:	1!
178	image_search_query += ' "{}"'.format(	1✔
179	tidy_party_name(party.name)
180	)
181	post = last_candidacy.ballot.post	1✔
182	if post is not None:	1!
183	image_search_query += ' "{}"'.format(post.label)	1✔
184	return "https://www.google.co.uk/search?tbm=isch&q={}".format(	1✔
185	quote(image_search_query)
186	)
187
188	def get_google_reverse_image_search_url(self, image_url):	1✔
189	url = "https://www.google.com/searchbyimage?&image_url="	1✔
190	absolute_image_url = self.request.build_absolute_uri(image_url)	1✔
191	return url + quote(absolute_image_url)	1✔
192
193	def get_context_data(self, **kwargs):	1✔
194	context = super().get_context_data(**kwargs)	1✔
195	self.queued_image = get_object_or_404(	1✔
196	QueuedImage, pk=kwargs["queued_image_id"]
197	)
198	context["queued_image"] = self.queued_image	1✔
199	if context["queued_image"].user:	1✔
200	username = context["queued_image"].user.username	1✔
201	email = context["queued_image"].user.email	1✔
202	else:
203	username = "a robot 🤖"	1✔
204	email = None	1✔
205	context["username"] = username	1✔
206	context["email"] = email	1✔
207	person = Person.objects.get(id=self.queued_image.person.id)	1✔
208	context["has_crop_bounds"] = int(self.queued_image.has_crop_bounds)	1✔
209	max_x = self.queued_image.image.width - 1	1✔
210	max_y = self.queued_image.image.height - 1	1✔
211	guessed_crop_bounds = [	1✔
212	value_if_none(self.queued_image.crop_min_x, 0),
213	value_if_none(self.queued_image.crop_min_y, 0),
214	value_if_none(self.queued_image.crop_max_x, max_x),
215	value_if_none(self.queued_image.crop_max_y, max_y),
216	]
217	context["form"] = PhotoReviewForm(	1✔
218	queued_image=self.queued_image,
219	request=self.request,
220	initial={
221	"queued_image_id": self.queued_image.id,
222	"decision": self.queued_image.decision,
223	"x_min": guessed_crop_bounds[0],
224	"y_min": guessed_crop_bounds[1],
225	"x_max": guessed_crop_bounds[2],
226	"y_max": guessed_crop_bounds[3],
227	"moderator_why_allowed": self.queued_image.why_allowed,
228	},
229	)
230	context["guessed_crop_bounds"] = guessed_crop_bounds	1✔
231	context["why_allowed"] = self.queued_image.why_allowed	1✔
232	context["moderator_why_allowed"] = self.queued_image.why_allowed	1✔
233	# There are often source links supplied in the justification,
234	# and it's convenient to be able to follow them. However, make
235	# sure that any maliciously added HTML tags have been stripped
236	# before linkifying any URLs:
237	context["justification_for_use"] = bleach.linkify(	1✔
238	bleach.clean(
239	self.queued_image.justification_for_use, tags=[], strip=True
240	)
241	)
242	context["google_image_search_url"] = self.get_google_image_search_url(	1✔
243	person
244	)
245	context[	1✔
246	"google_reverse_image_search_url"
247	] = self.get_google_reverse_image_search_url(
248	self.queued_image.image.url
249	)
250	context["person"] = person	1✔
251	return context	1✔
252
253	def form_valid(self, form):	1✔
254	self.queued_image = self.form.process()	1✔
255	if isinstance(form, PhotoReviewForm):	1!
256	candidate_link = f'<a href="{self.queued_image.person.get_absolute_url()}">{self.queued_image.person.name}</a>'	1✔
257	message_mapping = {	1✔
258	QueuedImage.APPROVED: f"You approved a photo upload for {candidate_link}",
259	QueuedImage.REJECTED: f"You rejected a photo upload for {candidate_link}",
260	QueuedImage.IGNORE: f"You left a photo upload for {candidate_link} in the queue",
261	QueuedImage.UNDECIDED: f"You indicated a photo upload for {candidate_link} should be ignored",
262	}
263	level_mapping = {QueuedImage.APPROVED: messages.SUCCESS}	1✔
264	message = message_mapping.get(self.queued_image.decision)	1✔
265	level = level_mapping.get(self.queued_image.decision, messages.INFO)	1✔
266	messages.add_message(	1✔
267	self.request, level, message, extra_tags="safe photo-review"
268	)
269	return HttpResponseRedirect(reverse("photo-review-list"))	1✔
UNCOV 270	return HttpResponseRedirect(	×
271	reverse(
272	"photo-review",
273	kwargs={"queued_image_id": self.queued_image.id},
274	)
275	)
276
277	def form_invalid(self, form):	1✔
UNCOV 278	return self.render_to_response(self.get_context_data(form=form))	×
279
280	def post(self, request, args, *kwargs):	1✔
281	self.queued_image = QueuedImage.objects.get(	1✔
282	pk=kwargs["queued_image_id"]
283	)
284	if "rotate" in request.POST:	1!
UNCOV 285	self.form = PhotoRotateForm(	×
286	data=self.request.POST,
287	request=request,
288	queued_image=self.queued_image,
289	)
290	else:
291	self.form = PhotoReviewForm(	1✔
292	data=self.request.POST,
293	request=request,
294	queued_image=self.queued_image,
295	)
296	if self.form.is_valid():	1!
297	return self.form_valid(self.form)	1✔
UNCOV 298	return self.form_invalid(self.form)	×
299
300
301	class SuggestLockView(LoginRequiredMixin, CreateView):	1✔
302	"""This handles creating a SuggestedPostLock from a form submission"""
303
304	model = SuggestedPostLock	1✔
305	form_class = SuggestedPostLockForm	1✔
306
307	def form_invalid(self, form):	1✔
308	messages.add_message(	1✔
309	request=self.request,
310	level=messages.ERROR,
311	message="Cannot add a lock suggestion because candidates are already locked",
312	extra_tags="ballot-changed",
313	)
314	return HttpResponseRedirect(form.instance.ballot.get_absolute_url())	1✔
315
316	def form_valid(self, form):	1✔
317	user = self.request.user	1✔
318	form.instance.user = user	1✔
319
320	LoggedAction.objects.create(	1✔
321	user=self.request.user,
322	action_type=ActionType.SUGGEST_BALLOT_LOCK,
323	ballot=form.cleaned_data["ballot"],
324	ip_address=get_client_ip(self.request),
325	source=form.cleaned_data["justification"],
326	)
327
328	messages.add_message(	1✔
329	self.request,
330	messages.SUCCESS,
331	message="Thanks for suggesting we lock an area!",
332	extra_tags="ballot-changed",
333	)
334
335	return super().form_valid(form)	1✔
336
337	def get_success_url(self):	1✔
338	return self.object.ballot.get_absolute_url()	1✔
339
340
341	class SuggestLockReviewListView(	1✔
342	GroupRequiredMixin, LoginRequiredMixin, TemplateView
343	):
344	"""
345	This is the view which lists all post lock suggestions that need review
346
347	Most people will get to this by clicking on the red highlighted 'Post lock
348	suggestions' counter in the header.
349	"""
350
351	template_name = "moderation_queue/suggestedpostlock_review.html"	1✔
352	required_group_name = TRUSTED_TO_LOCK_GROUP_NAME	1✔
353
354	def get_random_election(self):	1✔
355	"""
356	Get a random Election which has ballots with lock suggestions not
357	belonging to the user.
358	"""
359	# using annotate and order_by('?') produces strange results
360	# see https://code.djangoproject.com/ticket/26390
361	# so first do the annotation and filtering
362	num_lock_suggestions = Count(	1✔
363	"ballot",
364	filter=Q(ballot__suggestedpostlock__isnull=False)
365	& ~Q(ballot__suggestedpostlock__user=self.request.user),
366	)
367	elections = Election.objects.annotate(	1✔
368	num_lock_suggestions=num_lock_suggestions
369	).filter(num_lock_suggestions__gte=1)
370	# then use that QS to get the QS to randomise and return an object
371	return Election.objects.filter(pk__in=elections).order_by("?").first()	1✔
372
373	def get_lock_suggestions(self):	1✔
374	"""
375	Return a QuerySet of Ballot objects with lock suggestions unrelated to
376	the user in the request.
377	"""
378	return (	1✔
379	Ballot.objects.exclude(candidates_locked=True)
380	.exclude(
381	Q(suggestedpostlock__isnull=True)
382	\| Q(suggestedpostlock__user=self.request.user)
383	)
384	.select_related("election", "post")
385	.prefetch_related(
386	"officialdocument_set",
387	models.Prefetch(
388	"suggestedpostlock_set",
389	SuggestedPostLock.objects.select_related("user"),
390	),
391	models.Prefetch(
392	"membership_set",
393	Membership.objects.select_related(
394	"person", "party"
395	).prefetch_related(
396	"person__other_names", "previous_party_affiliations"
397	),
398	),
399	)
400	)
401
402	def get_context_data(self, **kwargs):	1✔
403	context = super().get_context_data(**kwargs)	1✔
404	ballots = self.get_lock_suggestions()	1✔
405	election = self.get_random_election()	1✔
406	context["total_ballots"] = ballots.count()	1✔
407	context["ballots"] = ballots.filter(election=election)[:10]	1✔
408	return context	1✔
409
410
411	class SOPNReviewRequiredView(ListView):	1✔
412	"""List all post that have a nominations paper, but no lock suggestion"""
413
414	template_name = "moderation_queue/sopn-review-required.html"	1✔
415
416	def get(self, args, *kwargs):	1✔
417	if "random" in self.request.GET:	1!
UNCOV 418	qs = self.get_queryset()	×
UNCOV 419	count = qs.count()	×
UNCOV 420	if count:	×
421	random_offset = random.randrange(count)	×
422	ballot = qs[random_offset]	×
423	url = ballot.get_bulk_add_url()	×
424	return HttpResponseRedirect(url)	×
425	return super().get(args, *kwargs)	1✔
426
427	def get_queryset(self):	1✔
428	"""
429	Ballot objects with a document but no lock suggestion
430	"""
431	return (	1✔
432	Ballot.objects.filter(
433	suggestedpostlock__isnull=True,
434	candidates_locked=False,
435	election__current=True,
436	)
437	.exclude(sopn=None)
438	.select_related("post", "election", "sopn")
439	.order_by("election", "post__label")
440	)
441
442
443	class PersonNameCleanupView(TemplateView):	1✔
444	template_name = "moderation_queue/person_name_cleanup.html"	1✔
445
446	def get_context_data(self, **kwargs):	1✔
UNCOV 447	context = super().get_context_data(**kwargs)	×
448
UNCOV 449	people = Person.objects.all().only("name")	×
450
UNCOV 451	regex = re.compile("[A-Z][A-Z]+")	×
452	context["two_upper"] = [p for p in people if regex.search(p.name)]	×
453
454	return context	×
455
456
457	class PersonNameEditReviewListView(GroupRequiredMixin, ListView):	1✔
458	http_method_names = ["get", "post"]	1✔
459	template_name = "moderation_queue/person_name_review.html"	1✔
460	required_group_name = TRUSTED_TO_EDIT_NAME	1✔
461	model = OtherName	1✔
462
463	def get_context_data(self, **kwargs):	1✔
464	context = super().get_context_data(**kwargs)	1✔
465	object_list = OtherName.objects.filter(needs_review=True)	1✔
466	context = super().get_context_data(**kwargs)	1✔
467	context["object_list"] = object_list	1✔
468
469	return context	1✔
470
471	def post(self, request, **kwargs):	1✔
472	other_name = OtherName.objects.get(pk=request.POST.get("other_name_pk"))	1✔
473
474	if "decision_approve" in request.POST:	1✔
475	self.approve_name_change(other_name)	1✔
476	elif "decision_reject" in request.POST:	1✔
477	self.reject_name_change(other_name)	1✔
478	elif "decision_delete" in request.POST:	1!
479	self.delete_name_change(other_name)	1✔
480
481	else:
UNCOV 482	raise ValueError("Invalid decision")	×
483	return HttpResponseRedirect(reverse("person-name-review"))	1✔
484
485	def approve_name_change(self, other_name):	1✔
486	person = other_name.content_object	1✔
487	person.edit_name(other_name.name, person.name, user=self.request.user)	1✔
488	person.save()	1✔
489
490	def delete_name_change(self, other_name):	1✔
491	other_name.delete()	1✔
492
493	def reject_name_change(self, other_name):	1✔
494	other_name.needs_review = False	1✔
495	other_name.save()	1✔
496
497
498	class RemoveSuggestedLocksView(LoginRequiredMixin, GroupRequiredMixin, View):	1✔
499	required_group_name = TRUSTED_TO_LOCK_GROUP_NAME	1✔
500
501	def post(self, request, args, *kwargs):	1✔
UNCOV 502	ballot = Ballot.objects.get(ballot_paper_id=request.POST["ballot"])	×
UNCOV 503	ballot.suggestedpostlock_set.all().delete()	×
UNCOV 504	if request.headers.get("x-requested-with") == "XMLHttpRequest":	×
505	return JsonResponse({"removed": True})	×
506	return HttpResponseRedirect(ballot.get_absolute_url())	×

DemocracyClub / yournextrepresentative / 6bb82f13-6848-4ec6-8bcf-80b08b2760de

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