re2o/users/forms.py

# -*- mode: python; coding: utf-8 -*-
# Re2o est un logiciel d'administration développé initiallement au Rézo Metz. Il
# se veut agnostique au réseau considéré, de manière à être installable en
# quelques clics.
#
# Copyright © 2017-2020  Gabriel Détraz
# Copyright © 2017-2020  Lara Kermarec
# Copyright © 2017-2020  Augustin Lemesle
# Copyright © 2017-2020  Hugo Levy--Falk
# Copyright © 2017-2020  Jean-Romain Garnier
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
Forms for the 'users' app of re2o. It highly depends on
:users:models and is mainly used by :users:views.

The following forms are mainly used to create, edit or delete
anything related to 'users' :
    * Adherent (personnal data)
    * Club
    * Ban
    * ServiceUser
    * Whitelists
    * ...

See the details for each of these operations in the documentation
of each of the method.
"""

from __future__ import unicode_literals

from os import walk, path

from django import forms
from django.forms import ModelForm, Form
from django.contrib.auth.forms import ReadOnlyPasswordHashField
from django.contrib.auth.password_validation import validate_password, password_validators_help_text_html
from django.core.validators import MinLengthValidator
from django.conf import settings
from django.utils import timezone
from django.utils.functional import lazy
from django.contrib.auth.models import Group, Permission
from django.utils.translation import ugettext_lazy as _
from django.utils.safestring import mark_safe

from machines.models import Interface, Machine, Nas
from topologie.models import Port
from preferences.models import OptionalUser
from re2o.utils import remove_user_room
from re2o.base import get_input_formats_help_text
from re2o.mixins import FormRevMixin, AutocompleteModelMixin
from re2o.field_permissions import FieldPermissionFormMixin

from preferences.models import GeneralOption

from .widgets import DateTimePicker

from .models import (
    User,
    ServiceUser,
    School,
    ListRight,
    Whitelist,
    EMailAddress,
    ListShell,
    Ban,
    Adherent,
    Club,
)


#### Django Admin Custom Views


class UserAdminForm(FormRevMixin, forms.ModelForm):
    """A form for creating new and editing users. Includes all the required
    fields, plus a repeated password.

    Parameters:
        DjangoForm : Inherit from basic django form
    """

    password1 = forms.CharField(
        label=_("Password"),
        widget=forms.PasswordInput,
        max_length=255,
        help_text=password_validators_help_text_html(),
        required=False,
    )
    password2 = forms.CharField(
        label=_("Password confirmation"),
        widget=forms.PasswordInput,
        max_length=255,
        required=False,
    )

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(UserAdminForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["email"].required = True

    class Meta:
        fields = ("pseudo", "surname", "name", "email", "is_superuser")

    def clean_password2(self):
        """Clean password 2, check if passwd1 and 2 values match.

        Parameters:
            self : Apply on a django Form UserCreationForm instance
            
        Returns:
            password2 (string): The password2 value if all tests returned True
        """
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2:
            if password1 and password2 and password1 != password2:
                raise forms.ValidationError(_("The passwords don't match."))
            validate_password(password1)
        return password2

    def save(self, commit=True):
        """Save function. Call standard "set_password" django function,
        from provided value for new password, for making hash.

        Parameters:
            self : Apply on a django Form UserCreationForm instance
            commit : If False, don't make the real save in database
        """
        # Save the provided password in hashed format
        user = super(UserAdminForm, self).save(commit=False)
        if self.cleaned_data["password1"]:
            user.set_password(self.cleaned_data["password1"])
            user.save()
        return user


class ServiceUserAdminForm(FormRevMixin, forms.ModelForm):
    """A form for creating new service users. Includes all the required
    fields, plus a repeated password. For Admin view purpose only.

    Parameters:
        DjangoForm : Inherit from basic django form
    """

    password1 = forms.CharField(
        label=_("Password"),
        widget=forms.PasswordInput,
        max_length=255,
    )
    password2 = forms.CharField(
        label=_("Password confirmation"),
        widget=forms.PasswordInput,
        max_length=255,
    )

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ServiceUserAdminForm, self).__init__(*args, prefix=prefix, **kwargs)

    class Meta:
        model = ServiceUser
        fields = ("pseudo",)

    def clean_password2(self):
        """Clean password 2, check if passwd1 and 2 values match.

        Parameters:
            self : Apply on a django Form UserCreationForm instance
 
        Returns:
            password2 (string): The password2 value if all tests returned True
        """
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError(_("The passwords don't match."))
        return password2

    def save(self, commit=True):
        """Save function. Call standard "set_password" django function,
        from provided value for new password, for making hash. 

        Parameters:
            self : Apply on a django Form ServiceUserAdminForm instance
            commit : If False, don't make the real save in database
        """
        user = super(ServiceUserAdminForm, self).save(commit=False)
        user.set_password(self.cleaned_data["password1"])
        user.save()
        return user


### Classic Django View


class PassForm(FormRevMixin, FieldPermissionFormMixin, forms.ModelForm):
    """Django form for changing password, check if 2 passwords are the same,
    and validate password for django base password validators provided in
    settings_local.
    
    Parameters:
        DjangoForm : Inherit from basic django form
        
    """
    selfpasswd = forms.CharField(
        label=_("Current password"), max_length=255, widget=forms.PasswordInput
    )
    passwd1 = forms.CharField(
        label=_("New password"),
        max_length=255,
        widget=forms.PasswordInput,
        help_text=password_validators_help_text_html()
    )
    passwd2 = forms.CharField(
        label=_("New password confirmation"),
        max_length=255,
        widget=forms.PasswordInput,
    )

    class Meta:
        model = User
        fields = []

    def clean_passwd2(self):
        """Clean password 2, check if passwd1 and 2 values match, and
        apply django validator with validate_password function. 
        
        Parameters:
            self : Apply on a django Form PassForm instance
            
        Returns:
            password2 (string): The password2 value if all tests returned True
        """
        password1 = self.cleaned_data.get("passwd1")
        password2 = self.cleaned_data.get("passwd2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError(_("The new passwords don't match."))
        validate_password(password1, user=self.instance)
        return password2

    def clean_selfpasswd(self):
        """Clean selfpassword, check if provided original user password match
        with the stored value.

        Parameters:
            self : Apply on a django Form PassForm instance
        """
        if not self.instance.check_password(self.cleaned_data.get("selfpasswd")):
            raise forms.ValidationError(_("The current password is incorrect."))
        return

    def save(self, commit=True):
        """Save function. Call standard "set_password" django function,
        and call set_active for set user in active state if needed.

        Parameters:
            self : Apply on a django Form PassForm instance
            commit : If False, don't make the real save in database
        """
        user = super(PassForm, self).save(commit=False)
        user.set_password(self.cleaned_data.get("passwd1"))
        user.save()


class ResetPasswordForm(forms.Form):
    """A form for asking to reset password. 

    Parameters:
        DjangoForm : Inherit from basic django form
    """    

    pseudo = forms.CharField(label=_("Username"), max_length=255)
    email = forms.EmailField(max_length=255)


class MassArchiveForm(forms.Form):
    """A form for archiving a lot de users. Get a start date
    for start archiving.

    Parameters:
        DjangoForm : Inherit from basic django form
    """   

    date = forms.DateTimeField(help_text="%d/%m/%y")
    full_archive = forms.BooleanField(
        label=_(
            "Fully archive users? WARNING: CRITICAL OPERATION IF TRUE"
        ),
        initial=False,
        required=False,
    )

    def clean(self):
        cleaned_data = super(MassArchiveForm, self).clean()
        date = cleaned_data.get("date")
        if date:
            if date > timezone.now():
                raise forms.ValidationError(
                    _(
                        "Impossible to archive users"
                        " whose end access date is in"
                        " the future."
                    )
                )


class AdherentForm(FormRevMixin, FieldPermissionFormMixin, ModelForm):
    """Adherent Edition Form, base form used for editing user by himself
    or another user. Labels are provided for help purposes.

    Parameters:
        DjangoForm : Inherit from basic django form
    """   

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(AdherentForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["name"].label = _("First name")
        self.fields["surname"].label = _("Surname")
        self.fields["email"].label = _("Email address")
        self.fields["school"].label = _("School")
        self.fields["comment"].label = _("Comment")
        if "room" in self.fields:
            self.fields["room"].label = _("Room")
            self.fields["room"].empty_label = _("No room")
        self.fields["school"].empty_label = _("Select a school")

    class Meta:
        model = Adherent
        fields = [
            "name",
            "surname",
            "pseudo",
            "email",
            "school",
            "comment",
            "telephone",
            "room",
        ]
        widgets = {
            "school": AutocompleteModelMixin(
                url="/users/school-autocomplete",
            ),
            "room": AutocompleteModelMixin(
                url="/topologie/room-autocomplete",
            ),
            "shell": AutocompleteModelMixin(
                url="/users/shell-autocomplete",
            )
        }

    force = forms.BooleanField(
        label=_("Force the move?"), initial=False, required=False
    )

    def clean_telephone(self):
        """Clean telephone, check if telephone is made mandatory, and
        raise error if not provided
        
        Parameters:
            self : Apply on a django Form AdherentForm instance
            
        Returns:
            telephone (string): The telephone string if clean is True
        """
        telephone = self.cleaned_data["telephone"]
        if not telephone and OptionalUser.get_cached_value("is_tel_mandatory"):
            raise forms.ValidationError(_("A valid telephone number is required."))
        return telephone

    def clean_force(self):
        """Clean force, remove previous user from room if needed.

        Parameters:
            self : Apply on a django Form AdherentForm instance
        """
        room = self.cleaned_data.get("room")
        if self.cleaned_data.get("force", False) and room:
            remove_user_room(room)
        return

    def clean_room(self):
        """Clean room, based on room policy provided by preferences.
        If needed, call remove_user_room to make the room empty before
        saving self.instance into that room.
        
        Parameters:
            self : Apply on a django Form AdherentForm instance
            
        Returns:
            room (string): The room instance
        """
        # Handle case where regular users can force move
        room = self.cleaned_data.get("room")
        room_policy = OptionalUser.get_cached_value("self_room_policy")
        if room_policy == OptionalUser.DISABLED or not room:
            return room

        # Remove the previous user's room, if allowed and necessary
        remove_user_room(room, force=bool(room_policy == OptionalUser.ALL_ROOM))

        # Run standard clean process
        return room


class AdherentCreationForm(AdherentForm):
    """AdherentCreationForm. Inherit from AdherentForm, base form used for creating
    user by himself or another user. Labels are provided for help purposes.
    Add some instructions, and validation for initial creation.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 
    # Champ pour choisir si un lien est envoyé par mail pour le mot de passe
    init_password_by_mail_info = _(
        "If this options is set, you will receive a link to set"
        " your initial password by email. If you do not have"
        " any means of accessing your emails, you can disable"
        " this option to set your password immediatly."
        " You will still receive an email to confirm your address."
        " Failure to confirm your address will result in an"
        " automatic suspension of your account until you do."
    )

    init_password_by_mail = forms.BooleanField(
        help_text=init_password_by_mail_info,
        required=False,
        initial=True
    )
    init_password_by_mail.label = _("Send password reset link by email.")

    # Champs pour initialiser le mot de passe
    # Validators are handled manually since theses fields aren't always required
    password1 = forms.CharField(
        required=False,
        label=_("Password"),
        widget=forms.PasswordInput,
        max_length=255,
        help_text=password_validators_help_text_html()
    )
    password2 = forms.CharField(
        required=False,
        label=_("Password confirmation"),
        widget=forms.PasswordInput,
        max_length=255,
    )

    # Champ permettant d'éviter au maxium les doublons d'utilisateurs
    former_user_check_info = _(
        "If you already have an account, please use it. If your lost access to"
        " it, please consider using the forgotten password button on the"
        " login page or contacting support."
    )
    former_user_check = forms.BooleanField(
        required=True, help_text=former_user_check_info
    )
    former_user_check.label = _("I certify that I have not had an account before.")

    # Checkbox for GTU
    gtu_check = forms.BooleanField(required=True)

    class Meta(AdherentForm.Meta):
        model = Adherent
        fields = [
            "name",
            "surname",
            "pseudo",
            "email",
            "school",
            "comment",
            "telephone",
            "room",
            "state",
        ]

    def __init__(self, *args, **kwargs):
        super(AdherentCreationForm, self).__init__(*args, **kwargs)
        gtu_file = GeneralOption.get_cached_value("GTU")
        self.fields["email"].required = True
        self.fields["gtu_check"].label = mark_safe(
            "%s <a href='%s' download='CGU'>%s</a>."
            % (
                _("I commit to accept the"),
                gtu_file.url if gtu_file else "#",
                _("General Terms of Use"),
            )
        )

        # Remove password fields if option is disabled
        if not OptionalUser.get_cached_value("allow_set_password_during_user_creation"):
            self.fields.pop("init_password_by_mail")
            self.fields.pop("password1")
            self.fields.pop("password2")

    def clean_password2(self):
        """Clean password 2, check if passwd1 and 2 values match, and
        apply django validator with validate_password function. 

        Parameters:
            self : Apply on a django Form AdherentCreationForm instance
            
        Returns:
            password2 (string): The password2 value if all tests returned True
        """
        send_email = self.cleaned_data.get("init_password_by_mail")
        if send_email:
            return None

        # Check that the two password entries match
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError(_("The passwords don't match."))
        validate_password(password1)
        return password2

    def save(self, commit=True):
        """Save function. If password has been set during creation, 
        call standard "set_password" django function from provided value
        for new password, for making hash.

        Parameters:
            self : Apply on a django Form AdherentCreationForm instance
            commit : If False, don't make the real save in database
        """
        # Save the provided password in hashed format
        user = super(AdherentForm, self).save(commit=False)

        is_set_password_allowed = OptionalUser.get_cached_value("allow_set_password_during_user_creation")
        set_passwd = is_set_password_allowed and not self.cleaned_data.get("init_password_by_mail")
        if set_passwd:
            user.set_password(self.cleaned_data["password1"])

        user.save()
        return user


class AdherentEditForm(AdherentForm):
    """AdherentEditForm. Inherit from AdherentForm, base form used for editing
    user by himself or another user. Labels are provided for help purposes.
    Add some instructions, and validation, fields depends on editing user rights.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        super(AdherentEditForm, self).__init__(*args, **kwargs)
        self.fields["gpg_fingerprint"].widget.attrs["placeholder"] = _(
            "Leave empty if you don't have any GPG key."
        )
        self.user = kwargs["instance"]
        self.fields["email"].required = bool(self.user.email)
        if "shell" in self.fields:
            self.fields["shell"].empty_label = _("Default shell")

    class Meta(AdherentForm.Meta):
        model = Adherent
        fields = [
            "name",
            "surname",
            "pseudo",
            "email",
            "school",
            "comment",
            "telephone",
            "room",
            "shell",
            "gpg_fingerprint",
            "shortcuts_enabled",
        ]


class ClubForm(FormRevMixin, FieldPermissionFormMixin, ModelForm):
    """ClubForm. For editing club by himself or another user. Labels are provided for
    help purposes. Add some instructions, and validation, fields depends 
    on editing user rights.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ClubForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["surname"].label = _("Name")
        self.fields["school"].label = _("School")
        self.fields["comment"].label = _("Comment")
        self.fields["email"].label = _("Email address")
        if "room" in self.fields:
            self.fields["room"].label = _("Room")
            self.fields["room"].empty_label = _("No room")
        self.fields["school"].empty_label = _("Select a school")
        self.fields["mailing"].label = _("Use a mailing list")

    class Meta:
        model = Club
        fields = [
            "surname",
            "pseudo",
            "school",
            "comment",
            "room",
            "email",
            "telephone",
            "email",
            "shell",
            "mailing",
        ]
        widgets = {
            "school": AutocompleteModelMixin(
                url="/users/school-autocomplete",
            ),
            "room": AutocompleteModelMixin(
                url="/topologie/room-autocomplete",
            ),
            "shell": AutocompleteModelMixin(
                url="/users/shell-autocomplete",
            )
        }

    def clean_telephone(self):
        """Clean telephone, check if telephone is made mandatory, and
        raise error if not provided
        
        Parameters:
            self : Apply on a django Form ClubForm instance
            
        Returns:
            telephone (string): The telephone string if clean is True
        """
        telephone = self.cleaned_data["telephone"]
        if not telephone and OptionalUser.get_cached_value("is_tel_mandatory"):
            raise forms.ValidationError(_("A valid telephone number is required."))
        return telephone


class ClubAdminandMembersForm(FormRevMixin, ModelForm):
    """ClubAdminandMembersForm. Only For editing administrators of a club by himself
    or another user.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta:
        model = Club
        fields = ["administrators", "members"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ClubAdminandMembersForm, self).__init__(*args, prefix=prefix, **kwargs)


class PasswordForm(FormRevMixin, ModelForm):
    """PasswordForm. Do not use directly in views without extra validations.
    
    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta:
        model = User
        fields = ["password", "pwd_ntlm"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(PasswordForm, self).__init__(*args, prefix=prefix, **kwargs)


class ServiceUserForm(FormRevMixin, ModelForm):
    """ServiceUserForm, used for creating a service user, require
    a password and set it.
    
    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    password = forms.CharField(
        label=_("New password"),
        max_length=255,
        validators=[MinLengthValidator(8)],
        widget=forms.PasswordInput,
        required=True,
    )

    class Meta:
        model = ServiceUser
        fields = ("pseudo", "access_group", "comment")

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ServiceUserForm, self).__init__(*args, prefix=prefix, **kwargs)

    def save(self, commit=True):
        """Save function. If password has been changed and provided, 
        call standard "set_password" django function from provided value
        for new password, for making hash.

        Parameters:
            self : Apply on a django Form ServiceUserForm instance
            commit : If False, don't make the real save in database
        """
        user = super(ServiceUserForm, self).save(commit=False)
        if self.cleaned_data["password"]:
            user.set_password(self.cleaned_data.get("password"))
        user.save()


class EditServiceUserForm(ServiceUserForm):
    """EditServiceUserForm, used for editing a service user, can
    edit password, access_group and comment.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    password = forms.CharField(
        label=_("New password"),
        max_length=255,
        validators=[MinLengthValidator(8)],
        widget=forms.PasswordInput,
        required=False,
    )

    class Meta(ServiceUserForm.Meta):
        fields = ["access_group", "comment"]


class StateForm(FormRevMixin, ModelForm):
    """StateForm, Change state of an user, and if
    its main email is verified or not

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta:
        model = User
        fields = ["state", "email_state"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(StateForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["state"].label = _("State")
        self.fields["email_state"].label = _("Email state")


class GroupForm(FieldPermissionFormMixin, FormRevMixin, ModelForm):
    """GroupForm, form used for editing user groups.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    groups = forms.ModelMultipleChoiceField(
        Group.objects.all(), widget=forms.CheckboxSelectMultiple, required=False
    )

    class Meta:
        model = User
        fields = ["is_superuser", "groups"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(GroupForm, self).__init__(*args, prefix=prefix, **kwargs)
        if "is_superuser" in self.fields:
            self.fields["is_superuser"].label = _("Superuser")


class SchoolForm(FormRevMixin, ModelForm):
    """SchoolForm, form used for creating or editing school.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta:
        model = School
        fields = ["name"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(SchoolForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["name"].label = _("School")


class ShellForm(FormRevMixin, ModelForm):
    """ShellForm, form used for creating or editing shell.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta:
        model = ListShell
        fields = ["shell"]

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ShellForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["shell"].label = _("Shell name")


class ListRightForm(FormRevMixin, ModelForm):
    """ListRightForm, form used for editing a listright,
    related with django group object. Gid, primary key, can't
    be edited.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    permissions = forms.ModelMultipleChoiceField(
        Permission.objects.all().select_related("content_type"),
        widget=forms.CheckboxSelectMultiple,
        required=False,
    )

    class Meta:
        model = ListRight
        fields = ("name", "unix_name", "critical", "permissions", "details")

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(ListRightForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["unix_name"].label = _("Name of the group of rights")


class NewListRightForm(ListRightForm):
    """ListRightForm, form used for creating a listright,
    related with django group object.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    class Meta(ListRightForm.Meta):
        fields = ("name", "unix_name", "gid", "critical", "permissions", "details")

    def __init__(self, *args, **kwargs):
        super(NewListRightForm, self).__init__(*args, **kwargs)
        self.fields["gid"].label = _(
            "GID. Warning: this field must not be edited after creation."
        )


class DelListRightForm(Form):
    """DelListRightForm, form for deleting one or several ListRight
    instances.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    listrights = forms.ModelMultipleChoiceField(
        queryset=ListRight.objects.none(),
        label=_("Current groups of rights"),
        widget=forms.CheckboxSelectMultiple,
    )

    def __init__(self, *args, **kwargs):
        instances = kwargs.pop("instances", None)
        super(DelListRightForm, self).__init__(*args, **kwargs)
        if instances:
            self.fields["listrights"].queryset = instances
        else:
            self.fields["listrights"].queryset = ListRight.objects.all()


class DelSchoolForm(Form):
    """DelSchoolForm, form for deleting one or several School
    instances.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    schools = forms.ModelMultipleChoiceField(
        queryset=School.objects.none(),
        label=_("Current schools"),
        widget=forms.CheckboxSelectMultiple,
    )

    def __init__(self, *args, **kwargs):
        instances = kwargs.pop("instances", None)
        super(DelSchoolForm, self).__init__(*args, **kwargs)
        if instances:
            self.fields["schools"].queryset = instances
        else:
            self.fields["schools"].queryset = School.objects.all()


class BanForm(FormRevMixin, ModelForm):
    """BanForm, form used for creating or editing a ban instance.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(BanForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["date_end"].label = _("End date")
        self.fields["date_end"].localize = False

    class Meta:
        model = Ban
        exclude = ["user"]
        widgets = {"date_end": DateTimePicker}


class WhitelistForm(FormRevMixin, ModelForm):
    """WhitelistForm, form used for creating or editing a whitelist instance.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(WhitelistForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["date_end"].label = _("End date")
        self.fields["date_end"].localize = False

    class Meta:
        model = Whitelist
        exclude = ["user"]
        widgets = {"date_end": DateTimePicker}


class EMailAddressForm(FormRevMixin, ModelForm):
    """EMailAddressForm, form used for creating or editing a local
    email for a user.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(EMailAddressForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.fields["local_part"].label = _("Local part of the email address")
        self.fields["local_part"].help_text = _("Can't contain @.")

    def clean_local_part(self):
        return self.cleaned_data.get("local_part").lower()

    class Meta:
        model = EMailAddress
        exclude = ["user"]


class EmailSettingsForm(FormRevMixin, FieldPermissionFormMixin, ModelForm):
    """EMailSettingsForm, form used for editing email settings for a user.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 

    def __init__(self, *args, **kwargs):
        prefix = kwargs.pop("prefix", self.Meta.model.__name__)
        super(EmailSettingsForm, self).__init__(*args, prefix=prefix, **kwargs)
        self.user = kwargs["instance"]
        self.fields["email"].label = _("Main email address")
        self.fields["email"].required = bool(self.user.email)
        if "local_email_redirect" in self.fields:
            self.fields["local_email_redirect"].label = _("Redirect local emails")
        if "local_email_enabled" in self.fields:
            self.fields["local_email_enabled"].label = _("Use local emails")

    class Meta:
        model = User
        fields = ["email", "local_email_enabled", "local_email_redirect"]


class InitialRegisterForm(forms.Form):
    """InitialRegisterForm, form used for auto-register of room and mac-address
    with captive-portal.

    Parameters:
        DjangoForm : Inherit from basic django form
    """ 
    register_room = forms.BooleanField(required=False)
    register_machine = forms.BooleanField(required=False)

    def __init__(self, *args, **kwargs):
        switch_ip = kwargs.pop("switch_ip")
        switch_port = kwargs.pop("switch_port")
        client_mac = kwargs.pop("client_mac")
        self.user = kwargs.pop("user")
        if switch_ip and switch_port:
            # Looking for a port
            port = Port.objects.filter(
                switch__interface__ipv4__ipv4=switch_ip, port=switch_port
            ).first()
            # If a port exists, checking there is a room AND radius
            if port:
                if (
                    port.get_port_profile.radius_type != "NO"
                    and port.get_port_profile.radius_mode == "STRICT"
                    and hasattr(port, "room")
                ):
                    # Requesting user is not in this room ?
                    if self.user.room != port.room:
                        self.new_room = port.room
        if client_mac and switch_ip:
            # If this interface doesn't already exists
            if not Interface.objects.filter(mac_address=client_mac):
                self.mac_address = client_mac
                self.nas_type = Nas.objects.filter(
                    nas_type__interface__ipv4__ipv4=switch_ip
                ).first()
        super(InitialRegisterForm, self).__init__(*args, **kwargs)
        if hasattr(self, "new_room"):
            self.fields["register_room"].label = _("This room is my room")
        else:
            self.fields.pop("register_room")
        if hasattr(self, "mac_address"):
            self.fields["register_machine"].label = _(
                "This new connected device is mine"
            )
        else:
            self.fields.pop("register_machine")

    def clean_register_room(self):
        """Clean room, call remove_user_room to make the room empty before
        saving self.instance into that room.
        
        Parameters:
            self : Apply on a django Form InitialRegisterForm instance
            
        """
        if self.cleaned_data["register_room"]:
            if self.user.is_class_adherent:
                remove_user_room(self.new_room)
                user = self.user.adherent
                user.room = self.new_room
                user.save()
            if self.user.is_class_club:
                user = self.user.club
                user.room = self.new_room
                user.save()

    def clean_register_machine(self):
        """Clean register room, autoregister machine from user request mac_address.

        Parameters:
            self : Apply on a django Form InitialRegisterForm instance
            
        """
        if self.cleaned_data["register_machine"]:
            if self.mac_address and self.nas_type:
                self.user.autoregister_machine(self.mac_address, self.nas_type)


class ThemeForm(FormRevMixin, forms.Form):
    """Form to change the theme of a user.
    """

    theme = forms.ChoiceField(widget=forms.Select())

    def __init__(self, *args, **kwargs):
        _, _ ,themes = next(walk(path.join(settings.STATIC_ROOT, "css/themes")))
        if not themes:
            themes = ["default.css"]
        super(ThemeForm, self).__init__(*args, **kwargs)
        self.fields['theme'].choices = [(theme, theme) for theme in themes]