11444866208

Committed 21 Oct 2024 04:51PM UTC coverage: 85.164% (-0.1%) from 85.283%

Build # 11444866208

Build Type

Pull #1391

github

Committed by

web-flow

Commit Message

Merge 1bc20b429 into d7192925a

Pull Request Pull Request #1391: Add management command to fix mariadb UUID issues

Run Details

2944 of 3454 branches covered (85.23%)

Branch coverage included in aggregate %.

0 of 26 new or added lines in 1 file covered. (0.0%)

14 existing lines in 2 files now uncovered.

11711 of 13754 relevant lines covered (85.15%)

0.85 hits per line

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

87.76

/ephios/plugins/baseshiftstructures/structure/named_teams.py

import uuid
from collections import Counter
from functools import cached_property
from itertools import groupby
from operator import itemgetter

from django import forms
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _

from ephios.core.models import AbstractParticipation, Qualification
from ephios.core.signup.disposition import BaseDispositionParticipationForm
from ephios.core.signup.flow.participant_validation import ParticipantUnfitError
from ephios.core.signup.forms import BaseSignupForm
from ephios.core.signup.participants import AbstractParticipant
from ephios.plugins.baseshiftstructures.structure.group_common import (
    AbstractGroupBasedStructureConfigurationForm,
    BaseGroupBasedShiftStructure,
    QualificationRequirementForm,
    format_min_max_count,
)


def teams_participant_qualifies_for(teams, participant: AbstractParticipant):
    available_qualification_ids = set(q.id for q in participant.collect_all_qualifications())
    return [
        team
        for team in teams
        if not (q := team.get("qualification")) or q in available_qualification_ids
    ]


class NamedTeamsDispositionParticipationForm(BaseDispositionParticipationForm):
    disposition_participation_template = (
        "baseshiftstructures/named_teams/fragment_participation.html"
    )

    team = forms.ChoiceField(
        label=_("Section"),
        required=False,  # only required if participation is confirmed
        widget=forms.Select(
            attrs={"data-show-for-state": str(AbstractParticipation.States.CONFIRMED)}
        ),
    )

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        teams = self.shift.structure.configuration.teams
        qualified_teams = list(
            teams_participant_qualifies_for(
                teams,
                self.instance.participant,
            )
        )
        unqualified_teams = [team for team in teams if team not in qualified_teams]
        self.fields["team"].choices = [("", "---")]
        if qualified_teams:
            self.fields["team"].choices += [
                (
                    _("qualified"),
                    [(team["uuid"], team["title"]) for team in qualified_teams],
                )
            ]
        if unqualified_teams:
            self.fields["team"].choices += [
                (
                    _("unqualified"),
                    [(team["uuid"], team["title"]) for team in unqualified_teams],
                )
            ]
        if preferred_team_uuid := self.instance.structure_data.get("preferred_team_uuid"):
            self.fields["team"].initial = preferred_team_uuid
            self.preferred_team = next(
                filter(lambda team: team["uuid"] == preferred_team_uuid, teams), None
            )
        if initial := self.instance.structure_data.get("dispatched_team_uuid"):
            self.fields["team"].initial = initial

    def clean(self):
        super().clean()
        if (
            self.cleaned_data["state"] == AbstractParticipation.States.CONFIRMED
            and not self.cleaned_data["team"]
        ):
            self.add_error(
                "team",
                ValidationError(_("You must select a team when confirming a participation.")),
            )

    def save(self, commit=True):
        self.instance.structure_data["dispatched_team_uuid"] = self.cleaned_data["team"]
        super().save(commit)


class NamedTeamsSignupForm(BaseSignupForm):
    preferred_team_uuid = forms.ChoiceField(
        label=_("Preferred Team"),
        widget=forms.RadioSelect,
        required=False,
        # choices are later set as (uuid, title) of team
    )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["preferred_team_uuid"].initial = self.instance.structure_data.get(
            "preferred_team_uuid"
        )
        self.fields["preferred_team_uuid"].required = (
            self.data.get("signup_choice") == "sign_up"
            and self.shift.structure.configuration.choose_preferred_team
        )
        self.fields["preferred_team_uuid"].choices = [
            (team["uuid"], team["title"]) for team in self.teams_participant_qualifies_for
        ]
        unqualified = [
            team
            for team in self.shift.structure.configuration.teams
            if team not in self.teams_participant_qualifies_for
        ]
        if unqualified:
            self.fields["preferred_team_uuid"].help_text = _(
                "You don't qualify for {teams}."
            ).format(teams=", ".join(str(team["title"]) for team in unqualified))

    def save(self, commit=True):
        self.instance.structure_data["preferred_team_uuid"] = self.cleaned_data[
            "preferred_team_uuid"
        ]
        return super().save(commit)

    @cached_property
    def teams_participant_qualifies_for(self):
        return teams_participant_qualifies_for(
            self.shift.structure.configuration.teams, self.participant
        )


class NamedTeamForm(QualificationRequirementForm):
    title = forms.CharField(label=_("Title"), required=True)
    uuid = forms.CharField(widget=forms.HiddenInput, required=False)

    def clean_uuid(self):
        return self.cleaned_data.get("uuid") or uuid.uuid4()


NamedTeamsFormset = forms.formset_factory(
    NamedTeamForm, can_delete=True, min_num=1, validate_min=1, extra=0
)


class NamedTeamsConfigurationForm(AbstractGroupBasedStructureConfigurationForm):
    template_name = "baseshiftstructures/named_teams/configuration_form.html"
    choose_preferred_team = forms.BooleanField(
        label=_("Participants must provide a preferred team"),
        help_text=_(
            "Participants will be asked during signup. This only makes sense if you configure multiple teams."
        ),
        widget=forms.CheckboxInput,
        required=False,
        initial=False,
    )
    teams = forms.Field(
        label=_("Teams"),
        widget=forms.HiddenInput,
        required=False,
    )
    formset_data_field_name = "teams"

    def get_formset_class(self):
        return NamedTeamsFormset

    @classmethod
    def format_formset_item(cls, item):
        return item["title"]


class NamedTeamsShiftStructure(BaseGroupBasedShiftStructure):
    slug = "named_teams"
    verbose_name = _("Named teams")
    description = _("Define named teams of participants with different requirements.")
    configuration_form_class = NamedTeamsConfigurationForm
    shift_state_template_name = "baseshiftstructures/named_teams/fragment_state.html"
    disposition_participation_form_class = NamedTeamsDispositionParticipationForm
    signup_form_class = NamedTeamsSignupForm

    NO_TEAM_UUID = "noteam"

    def _get_signup_stats_per_group(self, participations):
        from ephios.core.signup.stats import SignupStats

        confirmed_counter = Counter()
        requested_counter = Counter()
        for p in participations:
            if p.state == AbstractParticipation.States.CONFIRMED:
                c = confirmed_counter
            elif p.state == AbstractParticipation.States.REQUESTED:
                c = requested_counter
            else:
                continue
            team_uuid = p.structure_data.get("dispatched_team_uuid")
            if not team_uuid or team_uuid not in (
                team["uuid"] for team in self.configuration.teams
            ):
                team_uuid = self.NO_TEAM_UUID
            c[team_uuid] += 1

        d = {}
        for team in self.configuration.teams:
            team_uuid = team["uuid"]
            min_count = team.get("min_count")
            max_count = team.get("max_count")
            d[team_uuid] = SignupStats(
                requested_count=requested_counter[team_uuid],
                confirmed_count=confirmed_counter[team_uuid],
                missing=(max(min_count - confirmed_counter[team_uuid], 0) if min_count else 0),
                free=(max(max_count - confirmed_counter[team_uuid], 0) if max_count else None),
                min_count=min_count,
                max_count=max_count,
            )

        # Participations not assigned to a team are extra, so max and free are explicitly zero.
        # We do not offset missing places in other teams, as qualifications etc. might not match.
        # Disposition will always be required to resolve unassigned participations.
        d[self.NO_TEAM_UUID] = SignupStats(
            requested_count=requested_counter[self.NO_TEAM_UUID],
            confirmed_count=confirmed_counter[self.NO_TEAM_UUID],
            missing=0,
            free=0,
            min_count=None,
            max_count=0,
        )

        return d

    def get_checkers(self):
        def check_qualifications_and_max_count(shift, participant):
            viable_teams = teams_participant_qualifies_for(
                shift.structure.configuration.teams, participant
            )
            if not viable_teams:
                raise ParticipantUnfitError(_("You are not qualified."))

            # check if teams are full if signup flow does not use requested state
            if shift.signup_flow.uses_requested_state:
                return
            free_team = False
            for team in viable_teams:
                if (
                    team["max_count"] is None
                    or team["max_count"]
                    > shift.participations.filter(
                        state=AbstractParticipation.States.CONFIRMED,
                        structure_data__dispatched_team_uuid=team["uuid"],
                    ).count()
                ):
                    free_team = True
                    break
            if not free_team:
                raise ParticipantUnfitError(_("All teams you qualify for are full."))

        return super().get_checkers() + [check_qualifications_and_max_count]

    def _configure_participation(
        self, participation: AbstractParticipation, **kwargs
    ) -> AbstractParticipation:
        participation.state = AbstractParticipation.States.REQUESTED
        return participation

    def get_shift_state_context_data(self, request, **kwargs):
        context_data = super().get_shift_state_context_data(request)
        participations = context_data["participations"]
        teams_stats = self._get_signup_stats_per_group(participations)
        teams = {}
        for team in self.configuration.teams:
            try:
                qualification = Qualification.objects.get(id=team["qualification"])
            except Qualification.DoesNotExist:
                qualification = None
            teams[team["uuid"]] = {
                "title": team["title"],
                "placeholder": team.get("min_count") or 0,
                "qualification_label": qualification.abbreviation if qualification else "",
                "min_max_count": format_min_max_count(team.get("min_count"), team.get("max_count")),
                "participations": [],
                "stats": teams_stats[team["uuid"]],
            }

        unsorted_participations = []
        for participation in participations:
            dispatched_uuid = participation.structure_data.get(
                "dispatched_team_uuid"
            ) or participation.structure_data.get("preferred_team_uuid")
            if dispatched_uuid not in teams:
                unsorted_participations.append(participation)
            else:
                teams[dispatched_uuid]["participations"].append(participation)
                teams[dispatched_uuid]["placeholder"] -= 1

        for team in teams.values():
            team["placeholder"] = list(range(max(0, team["placeholder"])))
        if unsorted_participations:
            teams[self.NO_TEAM_UUID] = {
                "title": _("unassigned"),
                "participations": unsorted_participations,
                "placeholder": [],
                "stats": teams_stats[self.NO_TEAM_UUID],
            }

        context_data["teams"] = teams
        return context_data

    def _get_teams_with_users(self):
        team_by_uuid = {team["uuid"]: team for team in self.configuration.teams}
        # get name and preferred team uuid for confirmed participants
        # if they have a team assigned and we have that team on record
        confirmed_participations = [
            {
                "name": str(participation.participant),
                "relevant_qualifications": ", ".join(
                    participation.participant.qualifications.filter(
                        category__show_with_user=True,
                    )
                    .order_by("category", "abbreviation")
                    .values_list("abbreviation", flat=True)
                ),
                "uuid": dispatched_team_uuid,
            }
            for participation in self.shift.participations.filter(
                state=AbstractParticipation.States.CONFIRMED
            )
            if (dispatched_team_uuid := participation.structure_data.get("dispatched_team_uuid"))
            and dispatched_team_uuid in team_by_uuid
        ]
        # group by team and do some stats
        teams_with_users = [
            (
                team_by_uuid.pop(uuid),
                [[user["name"], user["relevant_qualifications"]] for user in group],
            )
            for uuid, group in groupby(
                sorted(confirmed_participations, key=itemgetter("uuid")), itemgetter("uuid")
            )
        ]
        # add teams without participants
        teams_with_users += [(team, None) for team in team_by_uuid.values()]
        return teams_with_users

    def get_participation_display(self):
        confirmed_teams_with_users = self._get_teams_with_users()
        participation_display = []
        for team, users in confirmed_teams_with_users:
            if users:
                participation_display += [[user[0], user[1], team["title"]] for user in users]
            if not users or len(users) < team["min_count"]:
                required_qualifications = ", ".join(
                    Qualification.objects.filter(pk__in=[team.get("qualification")]).values_list(
                        "abbreviation", flat=True
                    )
                )
                participation_display += [["", required_qualifications, team["title"]]] * (
                    team["min_count"] - (len(users) if users else 0)
                )
        return participation_display

1	import uuid	1✔
2	from collections import Counter	1✔
3	from functools import cached_property	1✔
4	from itertools import groupby	1✔
5	from operator import itemgetter	1✔
6
7	from django import forms	1✔
8	from django.core.exceptions import ValidationError	1✔
9	from django.utils.translation import gettext_lazy as _	1✔
10
11	from ephios.core.models import AbstractParticipation, Qualification	1✔
12	from ephios.core.signup.disposition import BaseDispositionParticipationForm	1✔
13	from ephios.core.signup.flow.participant_validation import ParticipantUnfitError	1✔
14	from ephios.core.signup.forms import BaseSignupForm	1✔
15	from ephios.core.signup.participants import AbstractParticipant	1✔
16	from ephios.plugins.baseshiftstructures.structure.group_common import (	1✔
17	AbstractGroupBasedStructureConfigurationForm,
18	BaseGroupBasedShiftStructure,
19	QualificationRequirementForm,
20	format_min_max_count,
21	)
22
23
24	def teams_participant_qualifies_for(teams, participant: AbstractParticipant):	1✔
25	available_qualification_ids = set(q.id for q in participant.collect_all_qualifications())	1✔
26	return [	1✔
27	team
28	for team in teams
29	if not (q := team.get("qualification")) or q in available_qualification_ids
30	]
31
32
33	class NamedTeamsDispositionParticipationForm(BaseDispositionParticipationForm):	1✔
34	disposition_participation_template = (	1✔
35	"baseshiftstructures/named_teams/fragment_participation.html"
36	)
37
38	team = forms.ChoiceField(	1✔
39	label=_("Section"),
40	required=False, # only required if participation is confirmed
41	widget=forms.Select(
42	attrs={"data-show-for-state": str(AbstractParticipation.States.CONFIRMED)}
43	),
44	)
45
46	def __init__(self, **kwargs):	1✔
47	super().__init__(**kwargs)	1✔
48	teams = self.shift.structure.configuration.teams	1✔
49	qualified_teams = list(	1✔
50	teams_participant_qualifies_for(
51	teams,
52	self.instance.participant,
53	)
54	)
55	unqualified_teams = [team for team in teams if team not in qualified_teams]	1✔
56	self.fields["team"].choices = [("", "---")]	1✔
57	if qualified_teams:	1!
58	self.fields["team"].choices += [	1✔
59	(
60	_("qualified"),
61	[(team["uuid"], team["title"]) for team in qualified_teams],
62	)
63	]
64	if unqualified_teams:	1!
65	self.fields["team"].choices += [	1✔
66	(
67	_("unqualified"),
68	[(team["uuid"], team["title"]) for team in unqualified_teams],
69	)
70	]
71	if preferred_team_uuid := self.instance.structure_data.get("preferred_team_uuid"):	1!
72	self.fields["team"].initial = preferred_team_uuid	1✔
73	self.preferred_team = next(	1✔
74	filter(lambda team: team["uuid"] == preferred_team_uuid, teams), None
75	)
76	if initial := self.instance.structure_data.get("dispatched_team_uuid"):	1!
UNCOV 77	self.fields["team"].initial = initial	×
78
79	def clean(self):	1✔
80	super().clean()	1✔
81	if (	1!
82	self.cleaned_data["state"] == AbstractParticipation.States.CONFIRMED
83	and not self.cleaned_data["team"]
84	):
UNCOV 85	self.add_error(	×
86	"team",
87	ValidationError(_("You must select a team when confirming a participation.")),
88	)
89
90	def save(self, commit=True):	1✔
91	self.instance.structure_data["dispatched_team_uuid"] = self.cleaned_data["team"]	1✔
92	super().save(commit)	1✔
93
94
95	class NamedTeamsSignupForm(BaseSignupForm):	1✔
96	preferred_team_uuid = forms.ChoiceField(	1✔
97	label=_("Preferred Team"),
98	widget=forms.RadioSelect,
99	required=False,
100	# choices are later set as (uuid, title) of team
101	)
102
103	def __init__(self, args, *kwargs):	1✔
104	super().__init__(args, *kwargs)	1✔
105	self.fields["preferred_team_uuid"].initial = self.instance.structure_data.get(	1✔
106	"preferred_team_uuid"
107	)
108	self.fields["preferred_team_uuid"].required = (	1✔
109	self.data.get("signup_choice") == "sign_up"
110	and self.shift.structure.configuration.choose_preferred_team
111	)
112	self.fields["preferred_team_uuid"].choices = [	1✔
113	(team["uuid"], team["title"]) for team in self.teams_participant_qualifies_for
114	]
115	unqualified = [	1✔
116	team
117	for team in self.shift.structure.configuration.teams
118	if team not in self.teams_participant_qualifies_for
119	]
120	if unqualified:	1!
121	self.fields["preferred_team_uuid"].help_text = _(	1✔
122	"You don't qualify for {teams}."
123	).format(teams=", ".join(str(team["title"]) for team in unqualified))
124
125	def save(self, commit=True):	1✔
126	self.instance.structure_data["preferred_team_uuid"] = self.cleaned_data[	1✔
127	"preferred_team_uuid"
128	]
129	return super().save(commit)	1✔
130
131	@cached_property	1✔
132	def teams_participant_qualifies_for(self):	1✔
133	return teams_participant_qualifies_for(	1✔
134	self.shift.structure.configuration.teams, self.participant
135	)
136
137
138	class NamedTeamForm(QualificationRequirementForm):	1✔
139	title = forms.CharField(label=_("Title"), required=True)	1✔
140	uuid = forms.CharField(widget=forms.HiddenInput, required=False)	1✔
141
142	def clean_uuid(self):	1✔
143	return self.cleaned_data.get("uuid") or uuid.uuid4()	1✔
144
145
146	NamedTeamsFormset = forms.formset_factory(	1✔
147	NamedTeamForm, can_delete=True, min_num=1, validate_min=1, extra=0
148	)
149
150
151	class NamedTeamsConfigurationForm(AbstractGroupBasedStructureConfigurationForm):	1✔
152	template_name = "baseshiftstructures/named_teams/configuration_form.html"	1✔
153	choose_preferred_team = forms.BooleanField(	1✔
154	label=_("Participants must provide a preferred team"),
155	help_text=_(
156	"Participants will be asked during signup. This only makes sense if you configure multiple teams."
157	),
158	widget=forms.CheckboxInput,
159	required=False,
160	initial=False,
161	)
162	teams = forms.Field(	1✔
163	label=_("Teams"),
164	widget=forms.HiddenInput,
165	required=False,
166	)
167	formset_data_field_name = "teams"	1✔
168
169	def get_formset_class(self):	1✔
170	return NamedTeamsFormset	1✔
171
172	@classmethod	1✔
173	def format_formset_item(cls, item):	1✔
174	return item["title"]	1✔
175
176
177	class NamedTeamsShiftStructure(BaseGroupBasedShiftStructure):	1✔
178	slug = "named_teams"	1✔
179	verbose_name = _("Named teams")	1✔
180	description = _("Define named teams of participants with different requirements.")	1✔
181	configuration_form_class = NamedTeamsConfigurationForm	1✔
182	shift_state_template_name = "baseshiftstructures/named_teams/fragment_state.html"	1✔
183	disposition_participation_form_class = NamedTeamsDispositionParticipationForm	1✔
184	signup_form_class = NamedTeamsSignupForm	1✔
185
186	NO_TEAM_UUID = "noteam"	1✔
187
188	def _get_signup_stats_per_group(self, participations):	1✔
189	from ephios.core.signup.stats import SignupStats	1✔
190
191	confirmed_counter = Counter()	1✔
192	requested_counter = Counter()	1✔
193	for p in participations:	1✔
194	if p.state == AbstractParticipation.States.CONFIRMED:	1✔
195	c = confirmed_counter	1✔
196	elif p.state == AbstractParticipation.States.REQUESTED:	1!
197	c = requested_counter	1✔
198	else:
UNCOV 199	continue	×
200	team_uuid = p.structure_data.get("dispatched_team_uuid")	1✔
201	if not team_uuid or team_uuid not in (	1!
202	team["uuid"] for team in self.configuration.teams
203	):
204	team_uuid = self.NO_TEAM_UUID	1✔
205	c[team_uuid] += 1	1✔
206
207	d = {}	1✔
208	for team in self.configuration.teams:	1✔
209	team_uuid = team["uuid"]	1✔
210	min_count = team.get("min_count")	1✔
211	max_count = team.get("max_count")	1✔
212	d[team_uuid] = SignupStats(	1✔
213	requested_count=requested_counter[team_uuid],
214	confirmed_count=confirmed_counter[team_uuid],
215	missing=(max(min_count - confirmed_counter[team_uuid], 0) if min_count else 0),
216	free=(max(max_count - confirmed_counter[team_uuid], 0) if max_count else None),
217	min_count=min_count,
218	max_count=max_count,
219	)
220
221	# Participations not assigned to a team are extra, so max and free are explicitly zero.
222	# We do not offset missing places in other teams, as qualifications etc. might not match.
223	# Disposition will always be required to resolve unassigned participations.
224	d[self.NO_TEAM_UUID] = SignupStats(	1✔
225	requested_count=requested_counter[self.NO_TEAM_UUID],
226	confirmed_count=confirmed_counter[self.NO_TEAM_UUID],
227	missing=0,
228	free=0,
229	min_count=None,
230	max_count=0,
231	)
232
233	return d	1✔
234
235	def get_checkers(self):	1✔
236	def check_qualifications_and_max_count(shift, participant):	1✔
237	viable_teams = teams_participant_qualifies_for(	1✔
238	shift.structure.configuration.teams, participant
239	)
240	if not viable_teams:	1!
UNCOV 241	raise ParticipantUnfitError(_("You are not qualified."))	×
242
243	# check if teams are full if signup flow does not use requested state
244	if shift.signup_flow.uses_requested_state:	1!
245	return	1✔
UNCOV 246	free_team = False	×
UNCOV 247	for team in viable_teams:	×
UNCOV 248	if (	×
249	team["max_count"] is None
250	or team["max_count"]
251	> shift.participations.filter(
252	state=AbstractParticipation.States.CONFIRMED,
253	structure_data__dispatched_team_uuid=team["uuid"],
254	).count()
255	):
UNCOV 256	free_team = True	×
UNCOV 257	break	×
UNCOV 258	if not free_team:	×
UNCOV 259	raise ParticipantUnfitError(_("All teams you qualify for are full."))	×
260
261	return super().get_checkers() + [check_qualifications_and_max_count]	1✔
262
263	def _configure_participation(	1✔
264	self, participation: AbstractParticipation, **kwargs
265	) -> AbstractParticipation:
UNCOV 266	participation.state = AbstractParticipation.States.REQUESTED	×
UNCOV 267	return participation	×
268
269	def get_shift_state_context_data(self, request, **kwargs):	1✔
270	context_data = super().get_shift_state_context_data(request)	1✔
271	participations = context_data["participations"]	1✔
272	teams_stats = self._get_signup_stats_per_group(participations)	1✔
273	teams = {}	1✔
274	for team in self.configuration.teams:	1✔
275	try:	1✔
276	qualification = Qualification.objects.get(id=team["qualification"])	1✔
277	except Qualification.DoesNotExist:	1✔
278	qualification = None	1✔
279	teams[team["uuid"]] = {	1✔
280	"title": team["title"],
281	"placeholder": team.get("min_count") or 0,
282	"qualification_label": qualification.abbreviation if qualification else "",
283	"min_max_count": format_min_max_count(team.get("min_count"), team.get("max_count")),
284	"participations": [],
285	"stats": teams_stats[team["uuid"]],
286	}
287
288	unsorted_participations = []	1✔
289	for participation in participations:	1✔
290	dispatched_uuid = participation.structure_data.get(	1✔
291	"dispatched_team_uuid"
292	) or participation.structure_data.get("preferred_team_uuid")
293	if dispatched_uuid not in teams:	1✔
294	unsorted_participations.append(participation)	1✔
295	else:
296	teams[dispatched_uuid]["participations"].append(participation)	1✔
297	teams[dispatched_uuid]["placeholder"] -= 1	1✔
298
299	for team in teams.values():	1✔
300	team["placeholder"] = list(range(max(0, team["placeholder"])))	1✔
301	if unsorted_participations:	1✔
302	teams[self.NO_TEAM_UUID] = {	1✔
303	"title": _("unassigned"),
304	"participations": unsorted_participations,
305	"placeholder": [],
306	"stats": teams_stats[self.NO_TEAM_UUID],
307	}
308
309	context_data["teams"] = teams	1✔
310	return context_data	1✔
311
312	def _get_teams_with_users(self):	1✔
313	team_by_uuid = {team["uuid"]: team for team in self.configuration.teams}	1✔
314	# get name and preferred team uuid for confirmed participants
315	# if they have a team assigned and we have that team on record
316	confirmed_participations = [	1✔
317	{
318	"name": str(participation.participant),
319	"relevant_qualifications": ", ".join(
320	participation.participant.qualifications.filter(
321	category__show_with_user=True,
322	)
323	.order_by("category", "abbreviation")
324	.values_list("abbreviation", flat=True)
325	),
326	"uuid": dispatched_team_uuid,
327	}
328	for participation in self.shift.participations.filter(
329	state=AbstractParticipation.States.CONFIRMED
330	)
331	if (dispatched_team_uuid := participation.structure_data.get("dispatched_team_uuid"))
332	and dispatched_team_uuid in team_by_uuid
333	]
334	# group by team and do some stats
335	teams_with_users = [	1✔
336	(
337	team_by_uuid.pop(uuid),
338	[[user["name"], user["relevant_qualifications"]] for user in group],
339	)
340	for uuid, group in groupby(
341	sorted(confirmed_participations, key=itemgetter("uuid")), itemgetter("uuid")
342	)
343	]
344	# add teams without participants
345	teams_with_users += [(team, None) for team in team_by_uuid.values()]	1✔
346	return teams_with_users	1✔
347
348	def get_participation_display(self):	1✔
349	confirmed_teams_with_users = self._get_teams_with_users()	1✔
350	participation_display = []	1✔
351	for team, users in confirmed_teams_with_users:	1✔
352	if users:	1✔
353	participation_display += [[user[0], user[1], team["title"]] for user in users]	1✔
354	if not users or len(users) < team["min_count"]:	1!
355	required_qualifications = ", ".join(	1✔
356	Qualification.objects.filter(pk__in=[team.get("qualification")]).values_list(
357	"abbreviation", flat=True
358	)
359	)
360	participation_display += [["", required_qualifications, team["title"]]] * (	1✔
361	team["min_count"] - (len(users) if users else 0)
362	)
363	return participation_display	1✔

ephios-dev / ephios / 11444866208

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