10799462129

Committed 10 Sep 2024 07:41PM UTC coverage: 85.851% (-1.6%) from 87.44%

Build # 10799462129

Build Type

Pull #1343

github

Committed by

web-flow

Commit Message

Merge 4f4900b52 into 1e2dbc28e

Pull Request Pull Request #1343: Add complex shift structure

Run Details

2926 of 3402 branches covered (86.01%)

Branch coverage included in aggregate %.

203 of 442 new or added lines in 19 files covered. (45.93%)

5 existing lines in 3 files now uncovered.

11545 of 13454 relevant lines covered (85.81%)

0.86 hits per line

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

83.08

/ephios/plugins/complexsignup/models.py

import uuid

from django.db import models
from django.utils.translation import gettext_lazy as _

from ephios.core.models import Qualification
from ephios.modellogging.log import ModelFieldsLogConfig, register_model_for_logging


class BuildingBlockType(models.TextChoices):
    ATOMIC = "atomic", _("atomic")
    COMPOSITE = "composite", _("composite")


class BuildingBlock(models.Model):
    uuid = models.UUIDField("UUID", unique=True, default=uuid.uuid4)
    name = models.CharField(
        verbose_name=_("Name"),
        max_length=255,
        blank=False,
    )
    block_type = models.CharField(
        verbose_name=_("Type"), choices=BuildingBlockType.choices, max_length=64
    )

    # composite blocks
    sub_blocks = models.ManyToManyField(
        "self",
        through="BlockComposition",
        through_fields=("composite_block", "sub_block"),
        verbose_name=_("sub blocks"),
    )

    # atomic blocks
    allow_more = models.BooleanField(
        verbose_name=_("allow more"),
        help_text=_("Allow more participants that qualify for any of the positions."),
        default=False,
    )

    def __str__(self):
        return str(self.name)

    def is_composite(self):
        return self.block_type == BuildingBlockType.COMPOSITE.COMPOSITE.value

    class Meta:
        verbose_name = _("building block")
        verbose_name_plural = _("building blocks")


register_model_for_logging(
    BuildingBlock,
    ModelFieldsLogConfig(
        unlogged_fields=["uuid", "id"],
    ),
)


class BlockQualificationRequirement(models.Model):
    block = models.ForeignKey(
        BuildingBlock,
        on_delete=models.CASCADE,
        related_name="qualification_requirements",
        verbose_name=_("block"),
    )
    everyone = models.BooleanField(
        verbose_name=_("everyone"),
    )
    at_least = models.PositiveSmallIntegerField(
        default=0,
        verbose_name=_("at least"),
    )
    qualifications = models.ManyToManyField(
        Qualification, verbose_name=_("required qualifications")
    )

    def __str__(self):
        if self.everyone:
            return _("everyone on {block} needs {qualifications}").format(
                block=self.block, qualifications=", ".join(map(str, self.qualifications.all()))
            )
        return _("at least {at_least} on {block} need {qualifications}").format(
            at_least=self.at_least,
            block=self.block,
            qualifications=f" {_('and')} ".join(map(str, self.qualifications.all())),
        )

    class Meta:
        verbose_name = _("qualification requirement")
        verbose_name_plural = _("qualification requirements")


register_model_for_logging(
    BlockQualificationRequirement,
    ModelFieldsLogConfig(
        unlogged_fields=["block", "id"],
        attach_to_func=lambda instance: (BuildingBlock, instance.pk),
    ),
)


class Position(models.Model):
    block = models.ForeignKey(BuildingBlock, on_delete=models.CASCADE, related_name="positions")
    label = models.CharField(
        verbose_name=_("Label"),
        max_length=255,
        blank=True,
    )
    optional = models.BooleanField(
        verbose_name=_("optional"),
        default=False,
    )
    qualifications = models.ManyToManyField(
        Qualification,
        verbose_name=_("required qualifications"),
        blank=True,
    )

    def __str__(self):
        return _("{label_or_pk} on {block_name}").format(
            label_or_pk=self.label or self.pk, block_name=self.block.name
        )

    class Meta:
        verbose_name = _("position")
        verbose_name_plural = _("positions")


register_model_for_logging(
    Position,
    ModelFieldsLogConfig(
        unlogged_fields=["block", "id"],
        attach_to_func=lambda instance: (BuildingBlock, instance.block.pk),
    ),
)


class BlockComposition(models.Model):
    composite_block = models.ForeignKey(
        BuildingBlock,
        on_delete=models.CASCADE,
        related_name="sub_compositions",
        verbose_name=_("composite block"),
    )
    sub_block = models.ForeignKey(
        BuildingBlock,
        on_delete=models.CASCADE,
        related_name="super_compositions",
        verbose_name=_("sub block"),
    )
    label = models.CharField(
        verbose_name=_("Label"),
        max_length=255,
        blank=True,
    )
    optional = models.BooleanField(
        verbose_name=_("optional"),
        default=False,
    )

    def __str__(self):
        return _("{label} on {composite_blocK}").format(
            label=self.label or f"{self.sub_block.name} #{self.id}",
            composite_blocK=self.composite_block,
        )

    class Meta:
        verbose_name = _("block composition")
        verbose_name_plural = _("block compositions")


register_model_for_logging(
    BlockComposition,
    ModelFieldsLogConfig(
        unlogged_fields=["composite_block", "id"],
        attach_to_func=lambda instance: (BuildingBlock, instance.composite_block.pk),
    ),
)

1	import uuid	1✔
2
3	from django.db import models	1✔
4	from django.utils.translation import gettext_lazy as _	1✔
5
6	from ephios.core.models import Qualification	1✔
7	from ephios.modellogging.log import ModelFieldsLogConfig, register_model_for_logging	1✔
8
9
10	class BuildingBlockType(models.TextChoices):	1✔
11	ATOMIC = "atomic", _("atomic")	1✔
12	COMPOSITE = "composite", _("composite")	1✔
13
14
15	class BuildingBlock(models.Model):	1✔
16	uuid = models.UUIDField("UUID", unique=True, default=uuid.uuid4)	1✔
17	name = models.CharField(	1✔
18	verbose_name=_("Name"),
19	max_length=255,
20	blank=False,
21	)
22	block_type = models.CharField(	1✔
23	verbose_name=_("Type"), choices=BuildingBlockType.choices, max_length=64
24	)
25
26	# composite blocks
27	sub_blocks = models.ManyToManyField(	1✔
28	"self",
29	through="BlockComposition",
30	through_fields=("composite_block", "sub_block"),
31	verbose_name=_("sub blocks"),
32	)
33
34	# atomic blocks
35	allow_more = models.BooleanField(	1✔
36	verbose_name=_("allow more"),
37	help_text=_("Allow more participants that qualify for any of the positions."),
38	default=False,
39	)
40
41	def __str__(self):	1✔
42	return str(self.name)	1✔
43
44	def is_composite(self):	1✔
NEW 45	return self.block_type == BuildingBlockType.COMPOSITE.COMPOSITE.value	×
46
47	class Meta:	1✔
48	verbose_name = _("building block")	1✔
49	verbose_name_plural = _("building blocks")	1✔
50
51
52	register_model_for_logging(	1✔
53	BuildingBlock,
54	ModelFieldsLogConfig(
55	unlogged_fields=["uuid", "id"],
56	),
57	)
58
59
60	class BlockQualificationRequirement(models.Model):	1✔
61	block = models.ForeignKey(	1✔
62	BuildingBlock,
63	on_delete=models.CASCADE,
64	related_name="qualification_requirements",
65	verbose_name=_("block"),
66	)
67	everyone = models.BooleanField(	1✔
68	verbose_name=_("everyone"),
69	)
70	at_least = models.PositiveSmallIntegerField(	1✔
71	default=0,
72	verbose_name=_("at least"),
73	)
74	qualifications = models.ManyToManyField(	1✔
75	Qualification, verbose_name=_("required qualifications")
76	)
77
78	def __str__(self):	1✔
79	if self.everyone:	×
80	return _("everyone on {block} needs {qualifications}").format(	×
81	block=self.block, qualifications=", ".join(map(str, self.qualifications.all()))
82	)
83	return _("at least {at_least} on {block} need {qualifications}").format(	×
84	at_least=self.at_least,
85	block=self.block,
86	qualifications=f" {_('and')} ".join(map(str, self.qualifications.all())),
87	)
88
89	class Meta:	1✔
90	verbose_name = _("qualification requirement")	1✔
91	verbose_name_plural = _("qualification requirements")	1✔
92
93
94	register_model_for_logging(	1!
95	BlockQualificationRequirement,
96	ModelFieldsLogConfig(
97	unlogged_fields=["block", "id"],
98	attach_to_func=lambda instance: (BuildingBlock, instance.pk),
99	),
100	)
101
102
103	class Position(models.Model):	1✔
104	block = models.ForeignKey(BuildingBlock, on_delete=models.CASCADE, related_name="positions")	1✔
105	label = models.CharField(	1✔
106	verbose_name=_("Label"),
107	max_length=255,
108	blank=True,
109	)
110	optional = models.BooleanField(	1✔
111	verbose_name=_("optional"),
112	default=False,
113	)
114	qualifications = models.ManyToManyField(	1✔
115	Qualification,
116	verbose_name=_("required qualifications"),
117	blank=True,
118	)
119
120	def __str__(self):	1✔
121	return _("{label_or_pk} on {block_name}").format(	×
122	label_or_pk=self.label or self.pk, block_name=self.block.name
123	)
124
125	class Meta:	1✔
126	verbose_name = _("position")	1✔
127	verbose_name_plural = _("positions")	1✔
128
129
130	register_model_for_logging(	1!
131	Position,
132	ModelFieldsLogConfig(
133	unlogged_fields=["block", "id"],
134	attach_to_func=lambda instance: (BuildingBlock, instance.block.pk),
135	),
136	)
137
138
139	class BlockComposition(models.Model):	1✔
140	composite_block = models.ForeignKey(	1✔
141	BuildingBlock,
142	on_delete=models.CASCADE,
143	related_name="sub_compositions",
144	verbose_name=_("composite block"),
145	)
146	sub_block = models.ForeignKey(	1✔
147	BuildingBlock,
148	on_delete=models.CASCADE,
149	related_name="super_compositions",
150	verbose_name=_("sub block"),
151	)
152	label = models.CharField(	1✔
153	verbose_name=_("Label"),
154	max_length=255,
155	blank=True,
156	)
157	optional = models.BooleanField(	1✔
158	verbose_name=_("optional"),
159	default=False,
160	)
161
162	def __str__(self):	1✔
NEW 163	return _("{label} on {composite_blocK}").format(	×
164	label=self.label or f"{self.sub_block.name} #{self.id}",
165	composite_blocK=self.composite_block,
166	)
167
168	class Meta:	1✔
169	verbose_name = _("block composition")	1✔
170	verbose_name_plural = _("block compositions")	1✔
171
172
173	register_model_for_logging(	1!
174	BlockComposition,
175	ModelFieldsLogConfig(
176	unlogged_fields=["composite_block", "id"],
177	attach_to_func=lambda instance: (BuildingBlock, instance.composite_block.pk),
178	),
179	)

ephios-dev / ephios / 10799462129

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