Views

PermissionOrAuthorRequiredMixin

Bases: PermissionRequiredMixin

Require that the user has the required perm or is the object author.

This mixin can be used in combination with DetailView, or another base class that implements the get_object method.

Example

In the following code, a user will be able to edit news if he has the com.change_news permission or if he tries to edit his own news :

class NewsEditView(PermissionOrAuthorRequiredMixin, DetailView):
    model = News
    author_field = "author"
    permission_required = "com.change_news"

This is more or less equivalent to :

class NewsEditView(PermissionOrAuthorRequiredMixin, DetailView):
    model = News

    def dispatch(self, request, *args, **kwargs):
        self.object = self.get_object()
        if not (
            user.has_perm("com.change_news")
            or self.object.author == request.user
        ):
            raise PermissionDenied
        return super().dispatch(request, *args, **kwargs)

Notification

Bases: Model

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

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 not pk and not name:
        raise ValueError("You must either provide the id or the name of the group")
    group_id: int | None = (
        pk or Group.objects.filter(name=name).values_list("id", flat=True).first()
    )
    if group_id is None:
        return False
    if group_id == settings.SITH_GROUP_SUBSCRIBERS_ID:
        return self.is_subscribed
    if group_id == settings.SITH_GROUP_ROOT_ID:
        return self.is_root
    return any(g.id == group_id for g in self.cached_groups)

cached_groups()

Get the list of groups this user is in.

Source code in core/models.py

@cached_property
def cached_groups(self) -> list[Group]:
    """Get the list of groups this user is in."""
    return list(self.groups.all())

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_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"):
        if (
            hasattr(obj, "_prefetched_objects_cache")
            and "edit_groups" in obj._prefetched_objects_cache
        ):
            pks = [g.id for g in obj.edit_groups.all()]
        else:
            pks = list(obj.edit_groups.values_list("id", flat=True))
        if any(self.is_in_group(pk=pk) for pk in pks):
            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"):
        # if "view_groups" has already been prefetched, use
        # the prefetch cache, else fetch only the ids, to make
        # the query lighter.
        if (
            hasattr(obj, "_prefetched_objects_cache")
            and "view_groups" in obj._prefetched_objects_cache
        ):
            pks = [g.id for g in obj.view_groups.all()]
        else:
            pks = list(obj.view_groups.values_list("id", flat=True))
        if any(self.is_in_group(pk=pk) for pk in pks):
            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]

DetailFormView

Bases: FormView, BaseDetailView

Class that allow both a detail view and a form view.

UECommentForm(author_id, ue_id, is_creation, *args, **kwargs)

Bases: ModelForm

Form handeling creation and edit of an UEComment.

Source code in pedagogy/forms.py

def __init__(self, author_id, ue_id, is_creation, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.fields["author"].queryset = User.objects.filter(id=author_id).all()
    self.fields["author"].initial = author_id
    self.fields["ue"].queryset = UE.objects.filter(id=ue_id).all()
    self.fields["ue"].initial = ue_id
    self.is_creation = is_creation

UECommentModerationForm

Bases: Form

Form handeling bulk comment deletion.

UECommentReportForm(reporter_id, comment_id, *args, **kwargs)

Bases: ModelForm

Form handeling creation and edit of an UEReport.

Source code in pedagogy/forms.py

def __init__(self, reporter_id, comment_id, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.fields["reporter"].queryset = User.objects.filter(id=reporter_id).all()
    self.fields["reporter"].initial = reporter_id
    self.fields["comment"].queryset = UEComment.objects.filter(id=comment_id).all()
    self.fields["comment"].initial = comment_id

UEForm(author_id, *args, **kwargs)

Bases: ModelForm

Form handeling creation and edit of an UE.

Source code in pedagogy/forms.py

def __init__(self, author_id, *args, **kwargs):
    super().__init__(*args, **kwargs)
    self.fields["author"].queryset = User.objects.filter(id=author_id).all()
    self.fields["author"].initial = author_id

UE

Bases: Model

Contains infos about an UE (course).

has_user_already_commented(user)

Help prevent multiples comments from the same user.

This function checks that no other comment has been posted by a specified user.

Returns:

Type	Description
bool	True if the user has already posted a comment on this UE, else False.

Source code in pedagogy/models.py

def has_user_already_commented(self, user: User) -> bool:
    """Help prevent multiples comments from the same user.

    This function checks that no other comment has been posted by a specified user.

    Returns:
        True if the user has already posted a comment on this UE, else False.
    """
    return self.comments.filter(author=user).exists()

UEComment

Bases: Model

A comment about an UE.

UECommentReport

Bases: Model

Report an inapropriate comment.

UEDetailFormView

Bases: PermissionRequiredMixin, DetailFormView

Display every comment of an UE and detailed infos about it.

Allow to comment the UE.

UECommentUpdateView

Bases: PermissionOrAuthorRequiredMixin, UpdateView

Allow edit of a given comment.

UECommentDeleteView

Bases: PermissionOrAuthorRequiredMixin, DeleteView

Allow to delete a given comment.

UEGuideView

Bases: PermissionRequiredMixin, TemplateView

UE guide main page.

UECommentReportCreateView

Bases: PermissionRequiredMixin, CreateView

Create a new report for an inappropriate comment.

UEModerationFormView

Bases: PermissionRequiredMixin, FormView

Moderation interface (Privileged).

UECreateView

Bases: PermissionRequiredMixin, CreateView

Add a new UE (Privileged).

UEDeleteView

Bases: PermissionRequiredMixin, DeleteView

Allow to delete an UE (Privileged).

UEUpdateView

Bases: PermissionRequiredMixin, UpdateView

Allow to edit an UE (Privilegied).