12075552735

Committed 28 Nov 2024 09:19PM UTC coverage: 84.885% (+0.01%) from 84.875%

Build # 12075552735

Build Type

push

github

Committed by

felixrindt

Commit Message

change event add/delete permissions

Run Details

2956 of 3501 branches covered (84.43%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 2 files covered. (100.0%)

9 existing lines in 1 file now uncovered.

12027 of 14150 relevant lines covered (85.0%)

0.85 hits per line

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

86.57

/ephios/core/forms/events.py

import operator
import re
from datetime import date, datetime, timedelta

from crispy_forms.bootstrap import FormActions
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Field, Layout, Submit
from django import forms
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.core.exceptions import ValidationError
from django.db.models import Q
from django.forms.utils import from_current_timezone
from django.utils.timezone import make_aware
from django.utils.translation import gettext as _
from django_select2.forms import Select2MultipleWidget
from dynamic_preferences.forms import PreferenceForm
from guardian.shortcuts import assign_perm, get_objects_for_user, get_users_with_perms, remove_perm
from recurrence.forms import RecurrenceField

from ephios.core.dynamic_preferences_registry import event_type_preference_registry
from ephios.core.models import Event, EventType, LocalParticipation, Shift, UserProfile
from ephios.core.signup.flow import enabled_signup_flows, signup_flow_from_slug
from ephios.core.signup.structure import enabled_shift_structures, shift_structure_from_slug
from ephios.core.widgets import MultiUserProfileWidget
from ephios.extra.colors import clear_eventtype_color_css_fragment_cache
from ephios.extra.crispy import AbortLink
from ephios.extra.permissions import get_groups_with_perms
from ephios.extra.widgets import ColorInput, CustomDateInput, CustomTimeInput
from ephios.modellogging.log import add_log_recorder, update_log
from ephios.modellogging.recorders import (
    DerivedFieldsLogRecorder,
    InstanceActionType,
    PermissionLogRecorder,
)


class EventForm(forms.ModelForm):
    visible_for = forms.ModelMultipleChoiceField(
        queryset=Group.objects.none(),
        label=_("Visible for"),
        help_text=_(
            "Select groups which the event shall be visible for. Regardless, the event will be visible for users that already signed up."
        ),
        widget=Select2MultipleWidget,
        required=False,
    )
    responsible_users = forms.ModelMultipleChoiceField(
        queryset=UserProfile.objects.all(),
        required=False,
        label=_("Responsible persons"),
        widget=MultiUserProfileWidget,
    )
    responsible_groups = forms.ModelMultipleChoiceField(
        queryset=Group.objects.all(),
        required=False,
        label=_("Responsible groups"),
        widget=Select2MultipleWidget,
    )

    class Meta:
        model = Event
        fields = ["title", "type", "description", "location"]

    def __init__(self, **kwargs):
        user = kwargs.pop("user")
        can_publish_for_groups = get_objects_for_user(user, "publish_event_for_group", klass=Group)

        if (event := kwargs.get("instance", None)) is not None:
            self.eventtype = event.type
            responsible_users = get_users_with_perms(
                event, only_with_perms_in=["change_event"], with_group_users=False
            )
            responsible_groups = get_groups_with_perms(event, only_with_perms_in=["change_event"])
            visible_for = get_groups_with_perms(event, only_with_perms_in=["view_event"]).exclude(
                id__in=responsible_groups
            )

            self.locked_visible_for_groups = set(visible_for.exclude(id__in=can_publish_for_groups))
            kwargs["initial"] = {
                "visible_for": visible_for.filter(id__in=can_publish_for_groups),
                "responsible_users": responsible_users,
                "responsible_groups": responsible_groups,
                **kwargs.get("initial", {}),
            }
        else:
            # new event
            self.eventtype = kwargs.pop("eventtype")
            kwargs["initial"] = {
                "responsible_users": self.eventtype.preferences.get("responsible_users")
                | get_user_model().objects.filter(pk=user.pk),
                "responsible_groups": self.eventtype.preferences.get("responsible_groups"),
                "visible_for": self.eventtype.preferences.get("visible_for")
                or get_objects_for_user(user, "publish_event_for_group", klass=Group),
            }
            self.locked_visible_for_groups = set()

        super().__init__(**kwargs)

        if event is None:
            self.fields.pop("type")
        self.fields["visible_for"].queryset = can_publish_for_groups
        self.fields["visible_for"].disabled = not can_publish_for_groups
        if self.locked_visible_for_groups:
            self.fields["visible_for"].help_text = _(
                "Select groups which the event shall be visible for. "
                "This event is also visible for <b>{groups}</b>, "
                "but you don't have the permission to change visibility "
                "for those groups."
            ).format(groups=", ".join(group.name for group in self.locked_visible_for_groups))

    def save(self, commit=True):
        if not self.instance.pk:
            self.instance.type = self.eventtype
        event: Event = super().save(commit=commit)

        add_log_recorder(event, PermissionLogRecorder("view_event", _("Visible for")))
        add_log_recorder(event, PermissionLogRecorder("change_event", _("Responsibles")))

        # delete existing permissions
        # (better implement https://github.com/django-guardian/django-guardian/issues/654)
        for group in get_groups_with_perms(
            event, only_with_perms_in=["view_event", "change_event"], must_have_all_perms=False
        ):
            remove_perm("view_event", group, event)
            remove_perm("change_event", group, event)
        for user in get_users_with_perms(event, only_with_perms_in=["view_event", "change_event"]):
            remove_perm("view_event", user, event)
            remove_perm("change_event", user, event)

        # assign designated permissions
        assign_perm(
            "view_event",
            Group.objects.filter(
                Q(id__in=self.cleaned_data["visible_for"])
                | Q(id__in=self.cleaned_data["responsible_groups"])
                | Q(id__in=(g.id for g in self.locked_visible_for_groups))
            ),
            event,
        )
        assign_perm("change_event", self.cleaned_data["responsible_groups"], event)
        assign_perm("change_event", self.cleaned_data["responsible_users"], event)

        # Assign view_event to responsible users  and to non-responsible users
        # that already have some sort of participation for the event
        # (-> they saw and interacted with it)
        # We can't just do users that aren't included by group permissions,
        # as they might get removed from that group.
        assign_perm(
            "view_event",
            UserProfile.objects.filter(
                Q(pk__in=self.cleaned_data["responsible_users"])
                | Q(
                    pk__in=LocalParticipation.objects.filter(
                        shift_id__in=event.shifts.all()
                    ).values_list("user", flat=True)
                )
            ),
            event,
        )

        update_log(event, InstanceActionType.CHANGE)
        return event


class ShiftForm(forms.ModelForm):
    date = forms.DateField(widget=CustomDateInput, label=_("Date"))
    meeting_time = forms.TimeField(widget=CustomTimeInput, label=_("Meeting time"))
    start_time = forms.TimeField(widget=CustomTimeInput, label=_("Start time"))
    end_time = forms.TimeField(widget=CustomTimeInput, label=_("End time"))

    field_order = [
        "date",
        "meeting_time",
        "start_time",
        "end_time",
        "label",
        "signup_flow_slug",
        "structure_slug",
    ]

    class Meta:
        model = Shift
        fields = [
            "meeting_time",
            "start_time",
            "end_time",
            "label",
            "signup_flow_slug",
            "structure_slug",
        ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        signup_flows = list(enabled_signup_flows())
        # make sure that if a shift uses a disabled but installed flow, it is also available in the list
        if self.instance and (flow_slug := self.instance.signup_flow_slug):
            if flow_slug not in map(operator.attrgetter("slug"), signup_flows):
                try:
                    signup_flows.append(signup_flow_from_slug(flow_slug, self.instance))
                except ValueError:  # not installed
                    pass
        self.fields["signup_flow_slug"].widget = forms.Select(
            choices=((flow.slug, flow.verbose_name) for flow in signup_flows)
        )
        # same for structure
        shift_structures = list(enabled_shift_structures())
        if self.instance and (structure_slug := self.instance.structure_slug):
            if structure_slug not in map(operator.attrgetter("slug"), shift_structures):
                try:
                    shift_structures.append(
                        shift_structure_from_slug(structure_slug, self.instance)
                    )
                except ValueError:  # not installed
                    pass
        self.fields["structure_slug"].widget = forms.Select(
            choices=((structure.slug, structure.verbose_name) for structure in shift_structures)
        )
        # this recorder may cause db queries, so it's not added on Shift init, but here in the form
        # pylint: disable=undefined-variable
        add_log_recorder(
            self.instance,
            DerivedFieldsLogRecorder(lambda shift: shift.get_signup_info()),
        )

    def clean_meeting_time(self):
        return from_current_timezone(
            datetime.combine(self.cleaned_data["date"], self.cleaned_data["meeting_time"])
        )

    def clean_start_time(self):
        return from_current_timezone(
            datetime.combine(self.cleaned_data["date"], self.cleaned_data["start_time"])
        )

    def clean_end_time(self):
        end_time = datetime.combine(self.cleaned_data["date"], self.cleaned_data["end_time"])
        if make_aware(end_time) <= self.cleaned_data["start_time"]:
            end_time += timedelta(days=1)
        return from_current_timezone(end_time)

    def clean(self):
        cleaned_data = super().clean()
        if {"meeting_time", "start_time"} <= set(cleaned_data.keys()):
            if not cleaned_data["meeting_time"] <= cleaned_data["start_time"]:
                raise ValidationError(_("Meeting time must not be after start time!"))
        return cleaned_data


class EventDuplicationForm(forms.Form):
    start_date = forms.DateField(
        widget=CustomDateInput,
        initial=date.today(),
        help_text=_(
            "This date will be used as the start date for recurring events that you create below, e.g. daily events will be created from this date onwards."
        ),
        label=_("Start date"),
    )
    recurrence = RecurrenceField(required=False)


class EventTypeForm(forms.ModelForm):
    class Meta:
        model = EventType
        fields = ["title", "color"]
        widgets = {"color": ColorInput()}

    def clean_color(self):
        regex = re.compile(r"#[a-fA-F\d]{6}")
        if not regex.match(self.cleaned_data["color"]):
            raise ValidationError(_("You need to enter a valid color"))
        return self.cleaned_data["color"]

    def save(self, commit=True):
        clear_eventtype_color_css_fragment_cache()
        return super().save(commit=commit)


class EventTypePreferenceForm(PreferenceForm):
    registry = event_type_preference_registry


class BasePluginFormMixin:
    template_name = "core/fragments/plugin_form.html"

    @property
    def heading(self):
        raise NotImplementedError

    def is_function_active(self):
        """
        When building forms for additional features, return whether that feature is enabled for the form instance.
        With the default template, if this is True, the collapse is expanded on page load.
        """
        return False


class EventNotificationForm(forms.Form):
    NEW_EVENT = "new"
    REMINDER = "remind"
    PARTICIPANTS = "participants"
    action = forms.ChoiceField(
        choices=[
            (NEW_EVENT, _("Send notification about new event to everyone")),
            (REMINDER, _("Send reminder to everyone that is not participating")),
            (PARTICIPANTS, _("Send a message to all participants")),
        ],
        widget=forms.RadioSelect,
        label=False,
    )
    mail_content = forms.CharField(required=False, widget=forms.Textarea, label=_("Mail content"))

    def __init__(self, *args, **kwargs):
        self.event = kwargs.pop("event")
        super().__init__(*args, **kwargs)
        self.helper = FormHelper(self)
        self.helper.layout = Layout(
            Field("action"),
            Field("mail_content"),
            FormActions(
                Submit("submit", _("Send"), css_class="float-end"),
                AbortLink(href=self.event.get_absolute_url()),
            ),
        )

    def clean(self):
        if (
            self.cleaned_data.get("action") == self.PARTICIPANTS
            and not self.cleaned_data["mail_content"]
        ):
            raise ValidationError(_("You cannot send an empty mail."))
        return super().clean()

1	import operator	1✔
2	import re	1✔
3	from datetime import date, datetime, timedelta	1✔
4
5	from crispy_forms.bootstrap import FormActions	1✔
6	from crispy_forms.helper import FormHelper	1✔
7	from crispy_forms.layout import Field, Layout, Submit	1✔
8	from django import forms	1✔
9	from django.contrib.auth import get_user_model	1✔
10	from django.contrib.auth.models import Group	1✔
11	from django.core.exceptions import ValidationError	1✔
12	from django.db.models import Q	1✔
13	from django.forms.utils import from_current_timezone	1✔
14	from django.utils.timezone import make_aware	1✔
15	from django.utils.translation import gettext as _	1✔
16	from django_select2.forms import Select2MultipleWidget	1✔
17	from dynamic_preferences.forms import PreferenceForm	1✔
18	from guardian.shortcuts import assign_perm, get_objects_for_user, get_users_with_perms, remove_perm	1✔
19	from recurrence.forms import RecurrenceField	1✔
20
21	from ephios.core.dynamic_preferences_registry import event_type_preference_registry	1✔
22	from ephios.core.models import Event, EventType, LocalParticipation, Shift, UserProfile	1✔
23	from ephios.core.signup.flow import enabled_signup_flows, signup_flow_from_slug	1✔
24	from ephios.core.signup.structure import enabled_shift_structures, shift_structure_from_slug	1✔
25	from ephios.core.widgets import MultiUserProfileWidget	1✔
26	from ephios.extra.colors import clear_eventtype_color_css_fragment_cache	1✔
27	from ephios.extra.crispy import AbortLink	1✔
28	from ephios.extra.permissions import get_groups_with_perms	1✔
29	from ephios.extra.widgets import ColorInput, CustomDateInput, CustomTimeInput	1✔
30	from ephios.modellogging.log import add_log_recorder, update_log	1✔
31	from ephios.modellogging.recorders import (	1✔
32	DerivedFieldsLogRecorder,
33	InstanceActionType,
34	PermissionLogRecorder,
35	)
36
37
38	class EventForm(forms.ModelForm):	1✔
39	visible_for = forms.ModelMultipleChoiceField(	1✔
40	queryset=Group.objects.none(),
41	label=_("Visible for"),
42	help_text=_(
43	"Select groups which the event shall be visible for. Regardless, the event will be visible for users that already signed up."
44	),
45	widget=Select2MultipleWidget,
46	required=False,
47	)
48	responsible_users = forms.ModelMultipleChoiceField(	1✔
49	queryset=UserProfile.objects.all(),
50	required=False,
51	label=_("Responsible persons"),
52	widget=MultiUserProfileWidget,
53	)
54	responsible_groups = forms.ModelMultipleChoiceField(	1✔
55	queryset=Group.objects.all(),
56	required=False,
57	label=_("Responsible groups"),
58	widget=Select2MultipleWidget,
59	)
60
61	class Meta:	1✔
62	model = Event	1✔
63	fields = ["title", "type", "description", "location"]	1✔
64
65	def __init__(self, **kwargs):	1✔
66	user = kwargs.pop("user")	1✔
67	can_publish_for_groups = get_objects_for_user(user, "publish_event_for_group", klass=Group)	1✔
68
69	if (event := kwargs.get("instance", None)) is not None:	1✔
70	self.eventtype = event.type	1✔
71	responsible_users = get_users_with_perms(	1✔
72	event, only_with_perms_in=["change_event"], with_group_users=False
73	)
74	responsible_groups = get_groups_with_perms(event, only_with_perms_in=["change_event"])	1✔
75	visible_for = get_groups_with_perms(event, only_with_perms_in=["view_event"]).exclude(	1✔
76	id__in=responsible_groups
77	)
78
79	self.locked_visible_for_groups = set(visible_for.exclude(id__in=can_publish_for_groups))	1✔
80	kwargs["initial"] = {	1✔
81	"visible_for": visible_for.filter(id__in=can_publish_for_groups),
82	"responsible_users": responsible_users,
83	"responsible_groups": responsible_groups,
84	**kwargs.get("initial", {}),
85	}
86	else:
87	# new event
88	self.eventtype = kwargs.pop("eventtype")	1✔
89	kwargs["initial"] = {	1✔
90	"responsible_users": self.eventtype.preferences.get("responsible_users")
91	\| get_user_model().objects.filter(pk=user.pk),
92	"responsible_groups": self.eventtype.preferences.get("responsible_groups"),
93	"visible_for": self.eventtype.preferences.get("visible_for")
94	or get_objects_for_user(user, "publish_event_for_group", klass=Group),
95	}
96	self.locked_visible_for_groups = set()	1✔
97
98	super().__init__(**kwargs)	1✔
99
100	if event is None:	1✔
101	self.fields.pop("type")	1✔
102	self.fields["visible_for"].queryset = can_publish_for_groups	1✔
103	self.fields["visible_for"].disabled = not can_publish_for_groups	1✔
104	if self.locked_visible_for_groups:	1!
UNCOV 105	self.fields["visible_for"].help_text = _(	×
106	"Select groups which the event shall be visible for. "
107	"This event is also visible for <b>{groups}</b>, "
108	"but you don't have the permission to change visibility "
109	"for those groups."
110	).format(groups=", ".join(group.name for group in self.locked_visible_for_groups))
111
112	def save(self, commit=True):	1✔
113	if not self.instance.pk:	1✔
114	self.instance.type = self.eventtype	1✔
115	event: Event = super().save(commit=commit)	1✔
116
117	add_log_recorder(event, PermissionLogRecorder("view_event", _("Visible for")))	1✔
118	add_log_recorder(event, PermissionLogRecorder("change_event", _("Responsibles")))	1✔
119
120	# delete existing permissions
121	# (better implement https://github.com/django-guardian/django-guardian/issues/654)
122	for group in get_groups_with_perms(	1✔
123	event, only_with_perms_in=["view_event", "change_event"], must_have_all_perms=False
124	):
125	remove_perm("view_event", group, event)	1✔
126	remove_perm("change_event", group, event)	1✔
127	for user in get_users_with_perms(event, only_with_perms_in=["view_event", "change_event"]):	1✔
128	remove_perm("view_event", user, event)	1✔
129	remove_perm("change_event", user, event)	1✔
130
131	# assign designated permissions
132	assign_perm(	1✔
133	"view_event",
134	Group.objects.filter(
135	Q(id__in=self.cleaned_data["visible_for"])
136	\| Q(id__in=self.cleaned_data["responsible_groups"])
137	\| Q(id__in=(g.id for g in self.locked_visible_for_groups))
138	),
139	event,
140	)
141	assign_perm("change_event", self.cleaned_data["responsible_groups"], event)	1✔
142	assign_perm("change_event", self.cleaned_data["responsible_users"], event)	1✔
143
144	# Assign view_event to responsible users and to non-responsible users
145	# that already have some sort of participation for the event
146	# (-> they saw and interacted with it)
147	# We can't just do users that aren't included by group permissions,
148	# as they might get removed from that group.
149	assign_perm(	1✔
150	"view_event",
151	UserProfile.objects.filter(
152	Q(pk__in=self.cleaned_data["responsible_users"])
153	\| Q(
154	pk__in=LocalParticipation.objects.filter(
155	shift_id__in=event.shifts.all()
156	).values_list("user", flat=True)
157	)
158	),
159	event,
160	)
161
162	update_log(event, InstanceActionType.CHANGE)	1✔
163	return event	1✔
164
165
166	class ShiftForm(forms.ModelForm):	1✔
167	date = forms.DateField(widget=CustomDateInput, label=_("Date"))	1✔
168	meeting_time = forms.TimeField(widget=CustomTimeInput, label=_("Meeting time"))	1✔
169	start_time = forms.TimeField(widget=CustomTimeInput, label=_("Start time"))	1✔
170	end_time = forms.TimeField(widget=CustomTimeInput, label=_("End time"))	1✔
171
172	field_order = [	1✔
173	"date",
174	"meeting_time",
175	"start_time",
176	"end_time",
177	"label",
178	"signup_flow_slug",
179	"structure_slug",
180	]
181
182	class Meta:	1✔
183	model = Shift	1✔
184	fields = [	1✔
185	"meeting_time",
186	"start_time",
187	"end_time",
188	"label",
189	"signup_flow_slug",
190	"structure_slug",
191	]
192
193	def __init__(self, args, *kwargs):	1✔
194	super().__init__(args, *kwargs)	1✔
195	signup_flows = list(enabled_signup_flows())	1✔
196	# make sure that if a shift uses a disabled but installed flow, it is also available in the list
197	if self.instance and (flow_slug := self.instance.signup_flow_slug):	1✔
198	if flow_slug not in map(operator.attrgetter("slug"), signup_flows):	1!
199	try:	×
200	signup_flows.append(signup_flow_from_slug(flow_slug, self.instance))	×
201	except ValueError: # not installed	×
UNCOV 202	pass	×
203	self.fields["signup_flow_slug"].widget = forms.Select(	1✔
204	choices=((flow.slug, flow.verbose_name) for flow in signup_flows)
205	)
206	# same for structure
207	shift_structures = list(enabled_shift_structures())	1✔
208	if self.instance and (structure_slug := self.instance.structure_slug):	1✔
209	if structure_slug not in map(operator.attrgetter("slug"), shift_structures):	1!
210	try:	×
UNCOV 211	shift_structures.append(	×
212	shift_structure_from_slug(structure_slug, self.instance)
213	)
214	except ValueError: # not installed	×
UNCOV 215	pass	×
216	self.fields["structure_slug"].widget = forms.Select(	1✔
217	choices=((structure.slug, structure.verbose_name) for structure in shift_structures)
218	)
219	# this recorder may cause db queries, so it's not added on Shift init, but here in the form
220	# pylint: disable=undefined-variable
221	add_log_recorder(	1✔
222	self.instance,
223	DerivedFieldsLogRecorder(lambda shift: shift.get_signup_info()),
224	)
225
226	def clean_meeting_time(self):	1✔
227	return from_current_timezone(	1✔
228	datetime.combine(self.cleaned_data["date"], self.cleaned_data["meeting_time"])
229	)
230
231	def clean_start_time(self):	1✔
232	return from_current_timezone(	1✔
233	datetime.combine(self.cleaned_data["date"], self.cleaned_data["start_time"])
234	)
235
236	def clean_end_time(self):	1✔
237	end_time = datetime.combine(self.cleaned_data["date"], self.cleaned_data["end_time"])	1✔
238	if make_aware(end_time) <= self.cleaned_data["start_time"]:	1✔
239	end_time += timedelta(days=1)	1✔
240	return from_current_timezone(end_time)	1✔
241
242	def clean(self):	1✔
243	cleaned_data = super().clean()	1✔
244	if {"meeting_time", "start_time"} <= set(cleaned_data.keys()):	1!
245	if not cleaned_data["meeting_time"] <= cleaned_data["start_time"]:	1!
UNCOV 246	raise ValidationError(_("Meeting time must not be after start time!"))	×
247	return cleaned_data	1✔
248
249
250	class EventDuplicationForm(forms.Form):	1✔
251	start_date = forms.DateField(	1✔
252	widget=CustomDateInput,
253	initial=date.today(),
254	help_text=_(
255	"This date will be used as the start date for recurring events that you create below, e.g. daily events will be created from this date onwards."
256	),
257	label=_("Start date"),
258	)
259	recurrence = RecurrenceField(required=False)	1✔
260
261
262	class EventTypeForm(forms.ModelForm):	1✔
263	class Meta:	1✔
264	model = EventType	1✔
265	fields = ["title", "color"]	1✔
266	widgets = {"color": ColorInput()}	1✔
267
268	def clean_color(self):	1✔
269	regex = re.compile(r"#[a-fA-F\d]{6}")	×
270	if not regex.match(self.cleaned_data["color"]):	×
271	raise ValidationError(_("You need to enter a valid color"))	×
UNCOV 272	return self.cleaned_data["color"]	×
273
274	def save(self, commit=True):	1✔
275	clear_eventtype_color_css_fragment_cache()	×
UNCOV 276	return super().save(commit=commit)	×
277
278
279	class EventTypePreferenceForm(PreferenceForm):	1✔
280	registry = event_type_preference_registry	1✔
281
282
283	class BasePluginFormMixin:	1✔
284	template_name = "core/fragments/plugin_form.html"	1✔
285
286	@property	1✔
287	def heading(self):	1✔
UNCOV 288	raise NotImplementedError	×
289
290	def is_function_active(self):	1✔
291	"""
292	When building forms for additional features, return whether that feature is enabled for the form instance.
293	With the default template, if this is True, the collapse is expanded on page load.
294	"""
UNCOV 295	return False	×
296
297
298	class EventNotificationForm(forms.Form):	1✔
299	NEW_EVENT = "new"	1✔
300	REMINDER = "remind"	1✔
301	PARTICIPANTS = "participants"	1✔
302	action = forms.ChoiceField(	1✔
303	choices=[
304	(NEW_EVENT, _("Send notification about new event to everyone")),
305	(REMINDER, _("Send reminder to everyone that is not participating")),
306	(PARTICIPANTS, _("Send a message to all participants")),
307	],
308	widget=forms.RadioSelect,
309	label=False,
310	)
311	mail_content = forms.CharField(required=False, widget=forms.Textarea, label=_("Mail content"))	1✔
312
313	def __init__(self, args, *kwargs):	1✔
314	self.event = kwargs.pop("event")	1✔
315	super().__init__(args, *kwargs)	1✔
316	self.helper = FormHelper(self)	1✔
317	self.helper.layout = Layout(	1✔
318	Field("action"),
319	Field("mail_content"),
320	FormActions(
321	Submit("submit", _("Send"), css_class="float-end"),
322	AbortLink(href=self.event.get_absolute_url()),
323	),
324	)
325
326	def clean(self):	1✔
327	if (	1✔
328	self.cleaned_data.get("action") == self.PARTICIPANTS
329	and not self.cleaned_data["mail_content"]
330	):
331	raise ValidationError(_("You cannot send an empty mail."))	1✔
332	return super().clean()	1✔

ephios-dev / ephios / 12075552735

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