Views

CanCreateMixin

Bases: View

Protect any child view that would create an object.

Raises:

Type	Description
PermissionDenied	If the user has not the necessary permission to create the object of the view.

CanEditMixin

Bases: GenericContentPermissionMixinBuilder

Ensure the user has permission to edit this view's object.

Raises:

Type	Description
PermissionDenied	if the user cannot edit this view's object.

CanViewMixin

Bases: GenericContentPermissionMixinBuilder

Ensure the user has permission to view this view's object.

Raises:

Type	Description
PermissionDenied	if the user cannot edit this view's object.

Candidature

Bases: Model

This class is a component of responsability.

Election

Bases: Model

This class allows to create a new election.

ElectionList

Bases: Model

To allow per list vote.

Role

Bases: OrderedModel

This class allows to create a new role avaliable for a candidature.

Vote

Bases: Model

This class allows to vote for candidates.

User

Bases: AbstractUser

Defines the base user class, useable in every app.

This is almost the same as the auth module AbstractUser since it inherits from it, but some fields are required, and the username is generated automatically with the name of the user (see generate_username()).

Added field: nick_name, date_of_birth Required fields: email, first_name, last_name, date_of_birth

cached_groups: list[Group] property

Get the list of groups this user is in.

The result is cached for the default duration (should be 5 minutes)

Returns: A list of all the groups this user is in.

is_in_group(*, pk=None, name=None)

Check if this user is in the given group. Either a group id or a group name must be provided. If both are passed, only the id will be considered.

The group will be fetched using the given parameter. If no group is found, return False. If a group is found, check if this user is in the latter.

Returns:

Type	Description
bool	True if the user is the group, else False

Source code in core/models.py

def is_in_group(self, *, pk: int | None = None, name: str | None = None) -> bool:
    """Check if this user is in the given group.
    Either a group id or a group name must be provided.
    If both are passed, only the id will be considered.

    The group will be fetched using the given parameter.
    If no group is found, return False.
    If a group is found, check if this user is in the latter.

    Returns:
         True if the user is the group, else False
    """
    if pk is not None:
        group: Optional[Group] = get_group(pk=pk)
    elif name is not None:
        group: Optional[Group] = get_group(name=name)
    else:
        raise ValueError("You must either provide the id or the name of the group")
    if group is None:
        return False
    if group.id == settings.SITH_GROUP_PUBLIC_ID:
        return True
    if group.id == settings.SITH_GROUP_SUBSCRIBERS_ID:
        return self.is_subscribed
    if group.id == settings.SITH_GROUP_OLD_SUBSCRIBERS_ID:
        return self.was_subscribed
    if group.id == settings.SITH_GROUP_ROOT_ID:
        return self.is_root
    if group.is_meta:
        # check if this group is associated with a club
        group.__class__ = MetaGroup
        club = group.associated_club
        if club is None:
            return False
        membership = club.get_membership_for(self)
        if membership is None:
            return False
        if group.name.endswith(settings.SITH_MEMBER_SUFFIX):
            return True
        return membership.role > settings.SITH_MAXIMUM_FREE_ROLE
    return group in self.cached_groups

age()

Return the age this user has the day the method is called. If the user has not filled his age, return 0.

Source code in core/models.py

@cached_property
def age(self) -> int:
    """Return the age this user has the day the method is called.
    If the user has not filled his age, return 0.
    """
    if self.date_of_birth is None:
        return 0
    today = timezone.now()
    age = today.year - self.date_of_birth.year
    # remove a year if this year's birthday is yet to come
    age -= (today.month, today.day) < (
        self.date_of_birth.month,
        self.date_of_birth.day,
    )
    return age

get_short_name()

Returns the short name for the user.

Source code in core/models.py

def get_short_name(self):
    """Returns the short name for the user."""
    if self.nick_name:
        return self.nick_name
    return self.first_name + " " + self.last_name

get_display_name()

Returns the display name of the user.

A nickname if possible, otherwise, the full name.

Source code in core/models.py

def get_display_name(self) -> str:
    """Returns the display name of the user.

    A nickname if possible, otherwise, the full name.
    """
    if self.nick_name:
        return "%s (%s)" % (self.get_full_name(), self.nick_name)
    return self.get_full_name()

get_age()

Returns the age.

Source code in core/models.py

def get_age(self):
    """Returns the age."""
    today = timezone.now()
    born = self.date_of_birth
    return (
        today.year - born.year - ((today.month, today.day) < (born.month, born.day))
    )

get_family(godfathers_depth=4, godchildren_depth=4)

Get the family of the user, with the given depth.

Parameters:

Name	Type	Description	Default
godfathers_depth	NonNegativeInt	The number of generations of godfathers to fetch	4
godchildren_depth	NonNegativeInt	The number of generations of godchildren to fetch	4

Returns:

Type	Description
set[through]	A list of family relationships in this user's family

Source code in core/models.py

def get_family(
    self,
    godfathers_depth: NonNegativeInt = 4,
    godchildren_depth: NonNegativeInt = 4,
) -> set[User.godfathers.through]:
    """Get the family of the user, with the given depth.

    Args:
        godfathers_depth: The number of generations of godfathers to fetch
        godchildren_depth: The number of generations of godchildren to fetch

    Returns:
        A list of family relationships in this user's family
    """
    res = []
    for depth, key, reverse_key in [
        (godfathers_depth, "from_user_id", "to_user_id"),
        (godchildren_depth, "to_user_id", "from_user_id"),
    ]:
        if depth == 0:
            continue
        links = list(User.godfathers.through.objects.filter(**{key: self.id}))
        res.extend(links)
        for _ in range(1, depth):  # noqa: F402 we don't care about gettext here
            ids = [getattr(c, reverse_key) for c in links]
            links = list(
                User.godfathers.through.objects.filter(
                    **{f"{key}__in": ids}
                ).exclude(id__in=[r.id for r in res])
            )
            if not links:
                break
            res.extend(links)
    return set(res)

email_user(subject, message, from_email=None, **kwargs)

Sends an email to this User.

Source code in core/models.py

def email_user(self, subject, message, from_email=None, **kwargs):
    """Sends an email to this User."""
    if from_email is None:
        from_email = settings.DEFAULT_FROM_EMAIL
    send_mail(subject, message, from_email, [self.email], **kwargs)

generate_username()

Generates a unique username based on the first and last names.

For example: Guy Carlier gives gcarlier, and gcarlier1 if the first one exists.

Returns:

Type	Description
str	The generated username.

Source code in core/models.py

def generate_username(self) -> str:
    """Generates a unique username based on the first and last names.

    For example: Guy Carlier gives gcarlier, and gcarlier1 if the first one exists.

    Returns:
        The generated username.
    """

    def remove_accents(data):
        return "".join(
            x
            for x in unicodedata.normalize("NFKD", data)
            if unicodedata.category(x)[0] == "L"
        ).lower()

    user_name = (
        remove_accents(self.first_name[0] + self.last_name)
        .encode("ascii", "ignore")
        .decode("utf-8")
    )
    # load all usernames which could conflict with the new one.
    # we need to actually load them, instead of performing a count,
    # because we cannot be sure that two usernames refer to the
    # actual same word (eg. tmore and tmoreau)
    possible_conflicts: list[str] = list(
        User.objects.filter(username__startswith=user_name).values_list(
            "username", flat=True
        )
    )
    nb_conflicts = sum(
        1 for name in possible_conflicts if name.rstrip(string.digits) == user_name
    )
    if nb_conflicts > 0:
        user_name += str(nb_conflicts)  # exemple => exemple1
    self.username = user_name
    return user_name

is_owner(obj)

Determine if the object is owned by the user.

Source code in core/models.py

def is_owner(self, obj):
    """Determine if the object is owned by the user."""
    if hasattr(obj, "is_owned_by") and obj.is_owned_by(self):
        return True
    if hasattr(obj, "owner_group") and self.is_in_group(pk=obj.owner_group.id):
        return True
    return self.is_root

can_edit(obj)

Determine if the object can be edited by the user.

Source code in core/models.py

def can_edit(self, obj):
    """Determine if the object can be edited by the user."""
    if hasattr(obj, "can_be_edited_by") and obj.can_be_edited_by(self):
        return True
    if hasattr(obj, "edit_groups"):
        for pk in obj.edit_groups.values_list("pk", flat=True):
            if self.is_in_group(pk=pk):
                return True
    if isinstance(obj, User) and obj == self:
        return True
    return self.is_owner(obj)

can_view(obj)

Determine if the object can be viewed by the user.

Source code in core/models.py

def can_view(self, obj):
    """Determine if the object can be viewed by the user."""
    if hasattr(obj, "can_be_viewed_by") and obj.can_be_viewed_by(self):
        return True
    if hasattr(obj, "view_groups"):
        for pk in obj.view_groups.values_list("pk", flat=True):
            if self.is_in_group(pk=pk):
                return True
    return self.can_edit(obj)

clubs_with_rights()

The list of clubs where the user has rights

Source code in core/models.py

@cached_property
def clubs_with_rights(self) -> list[Club]:
    """The list of clubs where the user has rights"""
    memberships = self.memberships.ongoing().board().select_related("club")
    return [m.club for m in memberships]

LimitedCheckboxField(queryset, max_choice, **kwargs)

Bases: ModelMultipleChoiceField

A ModelMultipleChoiceField, with a max limit of selectable inputs.

Source code in election/views.py

def __init__(self, queryset, max_choice, **kwargs):
    self.max_choice = max_choice
    super().__init__(queryset, **kwargs)

CandidateForm(*args, **kwargs)

Bases: ModelForm

Form to candidate.

Source code in election/views.py

def __init__(self, *args, **kwargs):
    election_id = kwargs.pop("election_id", None)
    can_edit = kwargs.pop("can_edit", False)
    super().__init__(*args, **kwargs)
    if election_id:
        self.fields["role"].queryset = Role.objects.filter(
            election__id=election_id
        ).all()
        self.fields["election_list"].queryset = ElectionList.objects.filter(
            election__id=election_id
        ).all()
    if not can_edit:
        self.fields["user"].widget = forms.HiddenInput()

VoteForm(election, user, *args, **kwargs)

Bases: Form

Source code in election/views.py

def __init__(self, election, user, *args, **kwargs):
    super().__init__(*args, **kwargs)
    if not election.has_voted(user):
        for role in election.roles.all():
            cand = role.candidatures
            if role.max_choice > 1:
                self.fields[role.title] = LimitedCheckboxField(
                    cand, role.max_choice, required=False
                )
            else:
                self.fields[role.title] = forms.ModelChoiceField(
                    cand,
                    required=False,
                    widget=forms.RadioSelect(),
                    empty_label=_("Blank vote"),
                )

RoleForm(*args, **kwargs)

Bases: ModelForm

Form for creating a role.

Source code in election/views.py

def __init__(self, *args, **kwargs):
    election_id = kwargs.pop("election_id", None)
    super().__init__(*args, **kwargs)
    if election_id:
        self.fields["election"].queryset = Election.objects.filter(
            id=election_id
        ).all()

ElectionListForm(*args, **kwargs)

Bases: ModelForm

Source code in election/views.py

def __init__(self, *args, **kwargs):
    election_id = kwargs.pop("election_id", None)
    super().__init__(*args, **kwargs)
    if election_id:
        self.fields["election"].queryset = Election.objects.filter(
            id=election_id
        ).all()

ElectionForm

Bases: ModelForm

ElectionsListView

Bases: CanViewMixin, ListView

A list of all non archived elections visible.

ElectionListArchivedView

Bases: CanViewMixin, ListView

A list of all archived elections visible.

ElectionDetailView

Bases: CanViewMixin, DetailView

Details an election responsability by responsability.

get_context_data(**kwargs)

Add additionnal data to the template.

Source code in election/views.py

def get_context_data(self, **kwargs):
    """Add additionnal data to the template."""
    kwargs = super().get_context_data(**kwargs)
    kwargs["election_form"] = VoteForm(self.object, self.request.user)
    kwargs["election_results"] = self.object.results
    return kwargs

VoteFormView

Bases: CanCreateMixin, FormView

Alows users to vote.

form_valid(form)

Verify that the user is part in a vote group.

Source code in election/views.py

def form_valid(self, form):
    """Verify that the user is part in a vote group."""
    data = form.clean()
    res = super(FormView, self).form_valid(form)
    for grp_id in self.election.vote_groups.values_list("pk", flat=True):
        if self.request.user.is_in_group(pk=grp_id):
            self.vote(data)
            return res
    return res

get_context_data(**kwargs)

Add additionnal data to the template.

Source code in election/views.py

def get_context_data(self, **kwargs):
    """Add additionnal data to the template."""
    kwargs = super().get_context_data(**kwargs)
    kwargs["object"] = self.election
    kwargs["election"] = self.election
    kwargs["election_form"] = self.get_form()
    return kwargs

CandidatureCreateView

Bases: CanCreateMixin, CreateView

View dedicated to a cundidature creation.

form_valid(form)

Verify that the selected user is in candidate group.

Source code in election/views.py

def form_valid(self, form):
    """Verify that the selected user is in candidate group."""
    obj = form.instance
    obj.election = Election.objects.get(id=self.election.id)
    obj.user = obj.user if hasattr(obj, "user") else self.request.user
    if (obj.election.can_candidate(obj.user)) and (
        obj.user == self.request.user or self.can_edit
    ):
        return super(CreateView, self).form_valid(form)
    raise PermissionDenied

ElectionCreateView

Bases: CanCreateMixin, CreateView

form_valid(form)

Allow every user that had passed the dispatch to create an election.

Source code in election/views.py

def form_valid(self, form):
    """Allow every user that had passed the dispatch to create an election."""
    return super(CreateView, self).form_valid(form)

RoleCreateView

Bases: CanCreateMixin, CreateView

form_valid(form)

Verify that the user can edit properly.

Source code in election/views.py

def form_valid(self, form):
    """Verify that the user can edit properly."""
    obj: Role = form.instance
    user: User = self.request.user
    if obj.election:
        for grp_id in obj.election.edit_groups.values_list("pk", flat=True):
            if user.is_in_group(pk=grp_id):
                return super(CreateView, self).form_valid(form)
    raise PermissionDenied

ElectionListCreateView

Bases: CanCreateMixin, CreateView

form_valid(form)

Verify that the user can vote on this election.

Source code in election/views.py

def form_valid(self, form):
    """Verify that the user can vote on this election."""
    obj: ElectionList = form.instance
    user: User = self.request.user
    if obj.election:
        for grp_id in obj.election.candidature_groups.values_list("pk", flat=True):
            if user.is_in_group(pk=grp_id):
                return super(CreateView, self).form_valid(form)
        for grp_id in obj.election.edit_groups.values_list("pk", flat=True):
            if user.is_in_group(pk=grp_id):
                return super(CreateView, self).form_valid(form)
    raise PermissionDenied

ElectionUpdateView

Bases: CanEditMixin, UpdateView

CandidatureUpdateView

Bases: CanEditMixin, UpdateView

RoleUpdateView

Bases: CanEditMixin, UpdateView

ElectionDeleteView

Bases: DeleteView

CandidatureDeleteView

Bases: CanEditMixin, DeleteView

RoleDeleteView

Bases: CanEditMixin, DeleteView

ElectionListDeleteView

Bases: CanEditMixin, DeleteView