| {% trans "Name" %} | +{{ object.name }} | +
|---|
| {% trans "Name" %} | +{{ object.name }} | +
|---|---|
| {% trans "Description" %} | +{{ object.description|placeholder }} | +
| {% trans "Enabled" %} | +{% checkmark object.enabled %} | +
| {% trans "View" %} | +{% checkmark object.can_view %} | +
|---|---|
| {% trans "Add" %} | +{% checkmark object.can_add %} | +
| {% trans "Change" %} | +{% checkmark object.can_change %} | +
| {% trans "Delete" %} | +{% checkmark object.can_delete %} | +
{{ object.constraints|json }}
+ {% else %}
+ None
+ {% endif %}
+ | {% trans "Username" %} | +{{ object.username }} | +
|---|---|
| {% trans "Full Name" %} | +{{ object.get_full_name|placeholder }} | +
| {% trans "Email" %} | +{{ object.email|placeholder }} | +
| {% trans "Account Created" %} | +{{ object.date_joined|annotated_date }} | +
| {% trans "Active" %} | +{% checkmark object.active %} | +
| {% trans "Staff" %} | +{% checkmark object.is_staff %} | +
| {% trans "Superuser" %} | +{% checkmark object.is_superuser %} | +
{field_name}'
- field_kwargs = {
- 'label': preference.label,
- 'choices': preference.choices,
- 'help_text': mark_safe(help_text),
- 'coerce': preference.coerce,
- 'required': False,
- 'widget': forms.Select,
- }
- preference_fields[field_name] = forms.TypedChoiceField(**field_kwargs)
- attrs.update(preference_fields)
-
- return super().__new__(mcs, name, bases, attrs)
-
-
-class UserConfigForm(BootstrapMixin, forms.ModelForm, metaclass=UserConfigFormMetaclass):
- fieldsets = (
- ('User Interface', (
- 'pagination.per_page',
- 'pagination.placement',
- 'ui.colormode',
- )),
- ('Miscellaneous', (
- 'data_format',
- )),
- )
- # List of clearable preferences
- pk = forms.MultipleChoiceField(
- choices=[],
- required=False
- )
-
- class Meta:
- model = UserConfig
- fields = ()
-
- def __init__(self, *args, instance=None, **kwargs):
-
- # Get initial data from UserConfig instance
- initial_data = flatten_dict(instance.data)
- kwargs['initial'] = initial_data
-
- super().__init__(*args, instance=instance, **kwargs)
-
- # Compile clearable preference choices
- self.fields['pk'].choices = (
- (f'tables.{table_name}', '') for table_name in instance.data.get('tables', [])
- )
-
- def save(self, *args, **kwargs):
-
- # Set UserConfig data
- for pref_name, value in self.cleaned_data.items():
- if pref_name == 'pk':
- continue
- self.instance.set(pref_name, value, commit=False)
-
- # Clear selected preferences
- for preference in self.cleaned_data['pk']:
- self.instance.clear(preference)
-
- return super().save(*args, **kwargs)
-
- @property
- def plugin_fields(self):
- return [
- name for name in self.fields.keys() if name.startswith('plugins.')
- ]
-
-
-class TokenForm(BootstrapMixin, forms.ModelForm):
- key = forms.CharField(
- required=False,
- help_text=_("If no key is provided, one will be generated automatically.")
- )
- allowed_ips = SimpleArrayField(
- base_field=IPNetworkFormField(validators=[prefix_validator]),
- required=False,
- label=_('Allowed IPs'),
- help_text=_('Allowed IPv4/IPv6 networks from where the token can be used. Leave blank for no restrictions. '
- 'Example: 10.1.1.0/24,192.168.10.16/32,2001:db8:1::/64'),
- )
-
- class Meta:
- model = Token
- fields = [
- 'key', 'write_enabled', 'expires', 'description', 'allowed_ips',
- ]
- widgets = {
- 'expires': DateTimePicker(),
- }
-
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
-
- # Omit the key field if token retrieval is not permitted
- if self.instance.pk and not settings.ALLOW_TOKEN_RETRIEVAL:
- del self.fields['key']
diff --git a/netbox/users/forms/__init__.py b/netbox/users/forms/__init__.py
new file mode 100644
index 000000000..a545c3add
--- /dev/null
+++ b/netbox/users/forms/__init__.py
@@ -0,0 +1,5 @@
+from .authentication import *
+from .bulk_edit import *
+from .bulk_import import *
+from .filtersets import *
+from .model_forms import *
diff --git a/netbox/users/forms/authentication.py b/netbox/users/forms/authentication.py
new file mode 100644
index 000000000..2b540b752
--- /dev/null
+++ b/netbox/users/forms/authentication.py
@@ -0,0 +1,25 @@
+from django.contrib.auth.forms import (
+ AuthenticationForm,
+ PasswordChangeForm as DjangoPasswordChangeForm,
+)
+
+from utilities.forms import BootstrapMixin
+
+__all__ = (
+ 'LoginForm',
+ 'PasswordChangeForm',
+)
+
+
+class LoginForm(BootstrapMixin, AuthenticationForm):
+ """
+ Used to authenticate a user by username and password.
+ """
+ pass
+
+
+class PasswordChangeForm(BootstrapMixin, DjangoPasswordChangeForm):
+ """
+ This form enables a user to change his or her own password.
+ """
+ pass
diff --git a/netbox/users/forms/bulk_edit.py b/netbox/users/forms/bulk_edit.py
new file mode 100644
index 000000000..db40283ba
--- /dev/null
+++ b/netbox/users/forms/bulk_edit.py
@@ -0,0 +1,72 @@
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+from users.models import *
+from utilities.forms import BootstrapMixin
+from utilities.forms.widgets import BulkEditNullBooleanSelect
+
+__all__ = (
+ 'ObjectPermissionBulkEditForm',
+ 'UserBulkEditForm',
+)
+
+
+class UserBulkEditForm(BootstrapMixin, forms.Form):
+ pk = forms.ModelMultipleChoiceField(
+ queryset=NetBoxUser.objects.all(),
+ widget=forms.MultipleHiddenInput
+ )
+ first_name = forms.CharField(
+ label=_('First name'),
+ max_length=150,
+ required=False
+ )
+ last_name = forms.CharField(
+ label=_('Last name'),
+ max_length=150,
+ required=False
+ )
+ is_active = forms.NullBooleanField(
+ required=False,
+ widget=BulkEditNullBooleanSelect,
+ label=_('Active')
+ )
+ is_staff = forms.NullBooleanField(
+ required=False,
+ widget=BulkEditNullBooleanSelect,
+ label=_('Staff status')
+ )
+ is_superuser = forms.NullBooleanField(
+ required=False,
+ widget=BulkEditNullBooleanSelect,
+ label=_('Superuser status')
+ )
+
+ model = NetBoxUser
+ fieldsets = (
+ (None, ('first_name', 'last_name', 'is_active', 'is_staff', 'is_superuser')),
+ )
+ nullable_fields = ('first_name', 'last_name')
+
+
+class ObjectPermissionBulkEditForm(BootstrapMixin, forms.Form):
+ pk = forms.ModelMultipleChoiceField(
+ queryset=ObjectPermission.objects.all(),
+ widget=forms.MultipleHiddenInput
+ )
+ description = forms.CharField(
+ label=_('Description'),
+ max_length=200,
+ required=False
+ )
+ enabled = forms.NullBooleanField(
+ required=False,
+ widget=BulkEditNullBooleanSelect,
+ label=_('Enabled')
+ )
+
+ model = ObjectPermission
+ fieldsets = (
+ (None, ('enabled', 'description')),
+ )
+ nullable_fields = ('description',)
diff --git a/netbox/users/forms/bulk_import.py b/netbox/users/forms/bulk_import.py
new file mode 100644
index 000000000..25f779044
--- /dev/null
+++ b/netbox/users/forms/bulk_import.py
@@ -0,0 +1,32 @@
+from users.models import NetBoxGroup, NetBoxUser
+from utilities.forms import CSVModelForm
+
+__all__ = (
+ 'GroupImportForm',
+ 'UserImportForm',
+)
+
+
+class GroupImportForm(CSVModelForm):
+
+ class Meta:
+ model = NetBoxGroup
+ fields = (
+ 'name',
+ )
+
+
+class UserImportForm(CSVModelForm):
+
+ class Meta:
+ model = NetBoxUser
+ fields = (
+ 'username', 'first_name', 'last_name', 'email', 'password', 'is_staff',
+ 'is_active', 'is_superuser'
+ )
+
+ def save(self, *args, **kwargs):
+ # Set the hashed password
+ self.instance.set_password(self.cleaned_data.get('password'))
+
+ return super().save(*args, **kwargs)
diff --git a/netbox/users/forms/filtersets.py b/netbox/users/forms/filtersets.py
new file mode 100644
index 000000000..eca76dea4
--- /dev/null
+++ b/netbox/users/forms/filtersets.py
@@ -0,0 +1,111 @@
+from django import forms
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+from django.utils.translation import gettext_lazy as _
+
+from netbox.forms import NetBoxModelFilterSetForm
+from users.models import NetBoxGroup, NetBoxUser, ObjectPermission
+from utilities.forms import BOOLEAN_WITH_BLANK_CHOICES
+from utilities.forms.fields import DynamicModelMultipleChoiceField
+
+__all__ = (
+ 'GroupFilterForm',
+ 'ObjectPermissionFilterForm',
+ 'UserFilterForm',
+)
+
+
+class GroupFilterForm(NetBoxModelFilterSetForm):
+ model = NetBoxGroup
+ fieldsets = (
+ (None, ('q', 'filter_id',)),
+ )
+
+
+class UserFilterForm(NetBoxModelFilterSetForm):
+ model = NetBoxUser
+ fieldsets = (
+ (None, ('q', 'filter_id',)),
+ (_('Group'), ('group_id',)),
+ (_('Status'), ('is_active', 'is_staff', 'is_superuser')),
+ )
+ group_id = DynamicModelMultipleChoiceField(
+ queryset=Group.objects.all(),
+ required=False,
+ label=_('Group')
+ )
+ is_active = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Is Active'),
+ )
+ is_staff = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Is Staff'),
+ )
+ is_superuser = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Is Superuser'),
+ )
+
+
+class ObjectPermissionFilterForm(NetBoxModelFilterSetForm):
+ model = ObjectPermission
+ fieldsets = (
+ (None, ('q', 'filter_id',)),
+ (_('Permission'), ('enabled', 'group_id', 'user_id')),
+ (_('Actions'), ('can_view', 'can_add', 'can_change', 'can_delete')),
+ )
+ enabled = forms.NullBooleanField(
+ label=_('Enabled'),
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ )
+ )
+ group_id = DynamicModelMultipleChoiceField(
+ queryset=Group.objects.all(),
+ required=False,
+ label=_('Group')
+ )
+ user_id = DynamicModelMultipleChoiceField(
+ queryset=get_user_model().objects.all(),
+ required=False,
+ label=_('User')
+ )
+ can_view = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Can View'),
+ )
+ can_add = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Can Add'),
+ )
+ can_change = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Can Change'),
+ )
+ can_delete = forms.NullBooleanField(
+ required=False,
+ widget=forms.Select(
+ choices=BOOLEAN_WITH_BLANK_CHOICES
+ ),
+ label=_('Can Delete'),
+ )
diff --git a/netbox/users/forms/model_forms.py b/netbox/users/forms/model_forms.py
new file mode 100644
index 000000000..43b95893a
--- /dev/null
+++ b/netbox/users/forms/model_forms.py
@@ -0,0 +1,381 @@
+from django import forms
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.postgres.forms import SimpleArrayField
+from django.core.exceptions import FieldError
+from django.utils.html import mark_safe
+from django.utils.translation import gettext_lazy as _
+
+from ipam.formfields import IPNetworkFormField
+from ipam.validators import prefix_validator
+from netbox.preferences import PREFERENCES
+from users.constants import *
+from users.models import *
+from utilities.forms import BootstrapMixin
+from utilities.forms.fields import ContentTypeMultipleChoiceField, DynamicModelMultipleChoiceField
+from utilities.forms.widgets import DateTimePicker
+from utilities.permissions import qs_filter_from_constraints
+from utilities.utils import flatten_dict
+
+__all__ = (
+ 'GroupForm',
+ 'ObjectPermissionForm',
+ 'TokenForm',
+ 'UserConfigForm',
+ 'UserForm',
+)
+
+
+class UserConfigFormMetaclass(forms.models.ModelFormMetaclass):
+
+ def __new__(mcs, name, bases, attrs):
+
+ # Emulate a declared field for each supported user preference
+ preference_fields = {}
+ for field_name, preference in PREFERENCES.items():
+ description = f'{preference.description}{field_name}'
+ field_kwargs = {
+ 'label': preference.label,
+ 'choices': preference.choices,
+ 'help_text': mark_safe(help_text),
+ 'coerce': preference.coerce,
+ 'required': False,
+ 'widget': forms.Select,
+ }
+ preference_fields[field_name] = forms.TypedChoiceField(**field_kwargs)
+ attrs.update(preference_fields)
+
+ return super().__new__(mcs, name, bases, attrs)
+
+
+class UserConfigForm(BootstrapMixin, forms.ModelForm, metaclass=UserConfigFormMetaclass):
+ fieldsets = (
+ (_('User Interface'), (
+ 'pagination.per_page',
+ 'pagination.placement',
+ 'ui.colormode',
+ )),
+ (_('Miscellaneous'), (
+ 'data_format',
+ )),
+ )
+ # List of clearable preferences
+ pk = forms.MultipleChoiceField(
+ label=_('Pk'),
+ choices=[],
+ required=False
+ )
+
+ class Meta:
+ model = UserConfig
+ fields = ()
+
+ def __init__(self, *args, instance=None, **kwargs):
+
+ # Get initial data from UserConfig instance
+ initial_data = flatten_dict(instance.data)
+ kwargs['initial'] = initial_data
+
+ super().__init__(*args, instance=instance, **kwargs)
+
+ # Compile clearable preference choices
+ self.fields['pk'].choices = (
+ (f'tables.{table_name}', '') for table_name in instance.data.get('tables', [])
+ )
+
+ def save(self, *args, **kwargs):
+
+ # Set UserConfig data
+ for pref_name, value in self.cleaned_data.items():
+ if pref_name == 'pk':
+ continue
+ self.instance.set(pref_name, value, commit=False)
+
+ # Clear selected preferences
+ for preference in self.cleaned_data['pk']:
+ self.instance.clear(preference)
+
+ return super().save(*args, **kwargs)
+
+ @property
+ def plugin_fields(self):
+ return [
+ name for name in self.fields.keys() if name.startswith('plugins.')
+ ]
+
+
+class TokenForm(BootstrapMixin, forms.ModelForm):
+ key = forms.CharField(
+ label=_('Key'),
+ required=False,
+ help_text=_("If no key is provided, one will be generated automatically.")
+ )
+ allowed_ips = SimpleArrayField(
+ base_field=IPNetworkFormField(validators=[prefix_validator]),
+ required=False,
+ label=_('Allowed IPs'),
+ help_text=_('Allowed IPv4/IPv6 networks from where the token can be used. Leave blank for no restrictions. '
+ 'Example: 10.1.1.0/24,192.168.10.16/32,2001:db8:1::/64'),
+ )
+
+ class Meta:
+ model = Token
+ fields = [
+ 'key', 'write_enabled', 'expires', 'description', 'allowed_ips',
+ ]
+ widgets = {
+ 'expires': DateTimePicker(),
+ }
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ # Omit the key field if token retrieval is not permitted
+ if self.instance.pk and not settings.ALLOW_TOKEN_RETRIEVAL:
+ del self.fields['key']
+
+
+class UserForm(BootstrapMixin, forms.ModelForm):
+ password = forms.CharField(
+ label=_('Password'),
+ widget=forms.PasswordInput(),
+ required=True,
+ )
+ confirm_password = forms.CharField(
+ label=_('Confirm password'),
+ widget=forms.PasswordInput(),
+ required=True,
+ help_text=_("Enter the same password as before, for verification."),
+ )
+ groups = DynamicModelMultipleChoiceField(
+ label=_('Groups'),
+ required=False,
+ queryset=Group.objects.all()
+ )
+ object_permissions = DynamicModelMultipleChoiceField(
+ required=False,
+ label=_('Permissions'),
+ queryset=ObjectPermission.objects.all(),
+ to_field_name='pk',
+ )
+
+ fieldsets = (
+ (_('User'), ('username', 'password', 'confirm_password', 'first_name', 'last_name', 'email')),
+ (_('Groups'), ('groups', )),
+ (_('Status'), ('is_active', 'is_staff', 'is_superuser')),
+ (_('Permissions'), ('object_permissions',)),
+ )
+
+ class Meta:
+ model = NetBoxUser
+ fields = [
+ 'username', 'first_name', 'last_name', 'email', 'groups', 'object_permissions',
+ 'is_active', 'is_staff', 'is_superuser',
+ ]
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ if self.instance.pk:
+ # Populate assigned permissions
+ self.fields['object_permissions'].initial = self.instance.object_permissions.values_list('id', flat=True)
+
+ # Password fields are optional for existing Users
+ self.fields['password'].required = False
+ self.fields['password'].widget.attrs.pop('required')
+ self.fields['confirm_password'].required = False
+ self.fields['confirm_password'].widget.attrs.pop('required')
+
+ def save(self, *args, **kwargs):
+ instance = super().save(*args, **kwargs)
+
+ # Update assigned permissions
+ instance.object_permissions.set(self.cleaned_data['object_permissions'])
+
+ # On edit, check if we have to save the password
+ if self.cleaned_data.get('password'):
+ instance.set_password(self.cleaned_data.get('password'))
+ instance.save()
+
+ return instance
+
+ def clean(self):
+
+ # Check that password confirmation matches if password is set
+ if self.cleaned_data['password'] and self.cleaned_data['password'] != self.cleaned_data['confirm_password']:
+ raise forms.ValidationError(_("Passwords do not match! Please check your input and try again."))
+
+ # TODO: Move this logic to the NetBoxUser class
+ def clean_username(self):
+ """Reject usernames that differ only in case."""
+ instance = getattr(self, 'instance', None)
+ if instance:
+ qs = self._meta.model.objects.exclude(pk=instance.pk)
+ else:
+ qs = self._meta.model.objects.all()
+
+ username = self.cleaned_data.get("username")
+ if (
+ username and qs.filter(username__iexact=username).exists()
+ ):
+ raise forms.ValidationError(
+ _("user with this username already exists")
+ )
+
+ return username
+
+
+class GroupForm(BootstrapMixin, forms.ModelForm):
+ users = DynamicModelMultipleChoiceField(
+ label=_('Users'),
+ required=False,
+ queryset=get_user_model().objects.all()
+ )
+ object_permissions = DynamicModelMultipleChoiceField(
+ required=False,
+ label=_('Permissions'),
+ queryset=ObjectPermission.objects.all(),
+ to_field_name='pk',
+ )
+
+ fieldsets = (
+ (None, ('name', )),
+ (_('Users'), ('users', )),
+ (_('Permissions'), ('object_permissions', )),
+ )
+
+ class Meta:
+ model = NetBoxGroup
+ fields = [
+ 'name', 'users', 'object_permissions',
+ ]
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ # Populate assigned users and permissions
+ if self.instance.pk:
+ self.fields['users'].initial = self.instance.user_set.values_list('id', flat=True)
+ self.fields['object_permissions'].initial = self.instance.object_permissions.values_list('id', flat=True)
+
+ def save(self, *args, **kwargs):
+ instance = super().save(*args, **kwargs)
+
+ # Update assigned users and permissions
+ instance.user_set.set(self.cleaned_data['users'])
+ instance.object_permissions.set(self.cleaned_data['object_permissions'])
+
+ return instance
+
+
+class ObjectPermissionForm(BootstrapMixin, forms.ModelForm):
+ object_types = ContentTypeMultipleChoiceField(
+ label=_('Object types'),
+ queryset=ContentType.objects.all(),
+ limit_choices_to=OBJECTPERMISSION_OBJECT_TYPES,
+ widget=forms.SelectMultiple(attrs={'size': 6})
+ )
+ can_view = forms.BooleanField(
+ required=False
+ )
+ can_add = forms.BooleanField(
+ required=False
+ )
+ can_change = forms.BooleanField(
+ required=False
+ )
+ can_delete = forms.BooleanField(
+ required=False
+ )
+ actions = SimpleArrayField(
+ label=_('Additional actions'),
+ base_field=forms.CharField(),
+ required=False,
+ help_text=_('Actions granted in addition to those listed above')
+ )
+ users = DynamicModelMultipleChoiceField(
+ label=_('Users'),
+ required=False,
+ queryset=get_user_model().objects.all()
+ )
+ groups = DynamicModelMultipleChoiceField(
+ label=_('Groups'),
+ required=False,
+ queryset=Group.objects.all()
+ )
+
+ fieldsets = (
+ (None, ('name', 'description', 'enabled',)),
+ (_('Actions'), ('can_view', 'can_add', 'can_change', 'can_delete', 'actions')),
+ (_('Objects'), ('object_types', )),
+ (_('Assignment'), ('groups', 'users')),
+ (_('Constraints'), ('constraints',))
+ )
+
+ class Meta:
+ model = ObjectPermission
+ fields = [
+ 'name', 'description', 'enabled', 'object_types', 'users', 'groups', 'constraints', 'actions',
+ ]
+ help_texts = {
+ 'constraints': _(
+ 'JSON expression of a queryset filter that will return only permitted objects. Leave null '
+ 'to match all objects of this type. A list of multiple objects will result in a logical OR '
+ 'operation.'
+ )
+ }
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+ # Make the actions field optional since the form uses it only for non-CRUD actions
+ self.fields['actions'].required = False
+
+ # Order group and user fields
+ self.fields['groups'].queryset = self.fields['groups'].queryset.order_by('name')
+ self.fields['users'].queryset = self.fields['users'].queryset.order_by('username')
+
+ # Check the appropriate checkboxes when editing an existing ObjectPermission
+ if self.instance.pk:
+ for action in ['view', 'add', 'change', 'delete']:
+ if action in self.instance.actions:
+ self.fields[f'can_{action}'].initial = True
+ self.instance.actions.remove(action)
+
+ def clean(self):
+ super().clean()
+
+ object_types = self.cleaned_data.get('object_types')
+ constraints = self.cleaned_data.get('constraints')
+
+ # Append any of the selected CRUD checkboxes to the actions list
+ if not self.cleaned_data.get('actions'):
+ self.cleaned_data['actions'] = list()
+ for action in ['view', 'add', 'change', 'delete']:
+ if self.cleaned_data[f'can_{action}'] and action not in self.cleaned_data['actions']:
+ self.cleaned_data['actions'].append(action)
+
+ # At least one action must be specified
+ if not self.cleaned_data['actions']:
+ raise forms.ValidationError(_("At least one action must be selected."))
+
+ # Validate the specified model constraints by attempting to execute a query. We don't care whether the query
+ # returns anything; we just want to make sure the specified constraints are valid.
+ if object_types and constraints:
+ # Normalize the constraints to a list of dicts
+ if type(constraints) is not list:
+ constraints = [constraints]
+ for ct in object_types:
+ model = ct.model_class()
+ try:
+ tokens = {
+ CONSTRAINT_TOKEN_USER: 0, # Replace token with a null user ID
+ }
+ model.objects.filter(qs_filter_from_constraints(constraints, tokens)).exists()
+ except FieldError as e:
+ raise forms.ValidationError({
+ 'constraints': _('Invalid filter for {model}: {e}').format(model=model, e=e)
+ })
diff --git a/netbox/users/migrations/0004_netboxgroup_netboxuser.py b/netbox/users/migrations/0004_netboxgroup_netboxuser.py
new file mode 100644
index 000000000..59d941643
--- /dev/null
+++ b/netbox/users/migrations/0004_netboxgroup_netboxuser.py
@@ -0,0 +1,50 @@
+# Generated by Django 4.1.9 on 2023-06-06 18:15
+
+import django.contrib.auth.models
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ('auth', '0012_alter_user_first_name_max_length'),
+ ('users', '0003_token_allowed_ips_last_used'),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name='NetBoxGroup',
+ fields=[],
+ options={
+ 'verbose_name': 'Group',
+ 'proxy': True,
+ 'indexes': [],
+ 'constraints': [],
+ },
+ bases=('auth.group',),
+ managers=[
+ ('objects', django.contrib.auth.models.GroupManager()),
+ ],
+ ),
+ migrations.CreateModel(
+ name='NetBoxUser',
+ fields=[],
+ options={
+ 'verbose_name': 'User',
+ 'proxy': True,
+ 'indexes': [],
+ 'constraints': [],
+ },
+ bases=('auth.user',),
+ managers=[
+ ('objects', django.contrib.auth.models.UserManager()),
+ ],
+ ),
+ migrations.AlterModelOptions(
+ name='netboxgroup',
+ options={'ordering': ('name',), 'verbose_name': 'Group'},
+ ),
+ migrations.AlterModelOptions(
+ name='netboxuser',
+ options={'ordering': ('username',), 'verbose_name': 'User'},
+ ),
+ ]
diff --git a/netbox/users/models.py b/netbox/users/models.py
index 4e7d9ca52..a8060dd63 100644
--- a/netbox/users/models.py
+++ b/netbox/users/models.py
@@ -2,13 +2,14 @@ import binascii
import os
from django.conf import settings
-from django.contrib.auth.models import Group, User
+from django.contrib.auth.models import Group, GroupManager, User, UserManager
from django.contrib.contenttypes.models import ContentType
from django.contrib.postgres.fields import ArrayField
from django.core.validators import MinLengthValidator
from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver
+from django.urls import reverse
from django.utils import timezone
from django.utils.translation import gettext as _
from netaddr import IPNetwork
@@ -20,6 +21,8 @@ from utilities.utils import flatten_dict
from .constants import *
__all__ = (
+ 'NetBoxGroup',
+ 'NetBoxUser',
'ObjectPermission',
'Token',
'UserConfig',
@@ -30,6 +33,7 @@ __all__ = (
# Proxy models for admin
#
+
class AdminGroup(Group):
"""
Proxy contrib.auth.models.Group for the admin UI
@@ -48,6 +52,44 @@ class AdminUser(User):
proxy = True
+class NetBoxUserManager(UserManager.from_queryset(RestrictedQuerySet)):
+ pass
+
+
+class NetBoxGroupManager(GroupManager.from_queryset(RestrictedQuerySet)):
+ pass
+
+
+class NetBoxUser(User):
+ """
+ Proxy contrib.auth.models.User for the UI
+ """
+ objects = NetBoxUserManager()
+
+ class Meta:
+ verbose_name = 'User'
+ proxy = True
+ ordering = ('username',)
+
+ def get_absolute_url(self):
+ return reverse('users:netboxuser', args=[self.pk])
+
+
+class NetBoxGroup(Group):
+ """
+ Proxy contrib.auth.models.User for the UI
+ """
+ objects = NetBoxGroupManager()
+
+ class Meta:
+ verbose_name = 'Group'
+ proxy = True
+ ordering = ('name',)
+
+ def get_absolute_url(self):
+ return reverse('users:netboxgroup', args=[self.pk])
+
+
#
# User preferences
#
@@ -325,6 +367,22 @@ class ObjectPermission(models.Model):
def __str__(self):
return self.name
+ @property
+ def can_view(self):
+ return 'view' in self.actions
+
+ @property
+ def can_add(self):
+ return 'add' in self.actions
+
+ @property
+ def can_change(self):
+ return 'change' in self.actions
+
+ @property
+ def can_delete(self):
+ return 'delete' in self.actions
+
def list_constraints(self):
"""
Return all constraint sets as a list (even if only a single set is defined).
@@ -332,3 +390,6 @@ class ObjectPermission(models.Model):
if type(self.constraints) is not list:
return [self.constraints]
return self.constraints
+
+ def get_absolute_url(self):
+ return reverse('users:objectpermission', args=[self.pk])
diff --git a/netbox/users/tables.py b/netbox/users/tables.py
index cea50b10f..741a4b024 100644
--- a/netbox/users/tables.py
+++ b/netbox/users/tables.py
@@ -1,8 +1,14 @@
-from .models import Token
+import django_tables2 as tables
+
from netbox.tables import NetBoxTable, columns
+from users.models import NetBoxGroup, NetBoxUser, ObjectPermission
+from .models import Token
__all__ = (
+ 'GroupTable',
+ 'ObjectPermissionTable',
'TokenTable',
+ 'UserTable',
)
@@ -48,3 +54,72 @@ class TokenTable(NetBoxTable):
fields = (
'pk', 'description', 'key', 'write_enabled', 'created', 'expires', 'last_used', 'allowed_ips',
)
+
+
+class UserTable(NetBoxTable):
+ username = tables.Column(
+ linkify=True
+ )
+ groups = columns.ManyToManyColumn(
+ linkify_item=('users:netboxgroup', {'pk': tables.A('pk')})
+ )
+ is_active = columns.BooleanColumn()
+ is_staff = columns.BooleanColumn()
+ is_superuser = columns.BooleanColumn()
+ actions = columns.ActionsColumn(
+ actions=('edit', 'delete'),
+ )
+
+ class Meta(NetBoxTable.Meta):
+ model = NetBoxUser
+ fields = (
+ 'pk', 'id', 'username', 'first_name', 'last_name', 'email', 'groups', 'is_active', 'is_staff',
+ 'is_superuser',
+ )
+ default_columns = ('pk', 'username', 'first_name', 'last_name', 'email', 'is_active')
+
+
+class GroupTable(NetBoxTable):
+ name = tables.Column(linkify=True)
+ actions = columns.ActionsColumn(
+ actions=('edit', 'delete'),
+ )
+
+ class Meta(NetBoxTable.Meta):
+ model = NetBoxGroup
+ fields = (
+ 'pk', 'id', 'name', 'users_count',
+ )
+ default_columns = ('pk', 'name', 'users_count', )
+
+
+class ObjectPermissionTable(NetBoxTable):
+ name = tables.Column(linkify=True)
+ object_types = columns.ContentTypesColumn()
+ enabled = columns.BooleanColumn()
+ can_view = columns.BooleanColumn()
+ can_add = columns.BooleanColumn()
+ can_change = columns.BooleanColumn()
+ can_delete = columns.BooleanColumn()
+ custom_actions = columns.ArrayColumn(
+ accessor=tables.A('actions')
+ )
+ users = columns.ManyToManyColumn(
+ linkify_item=('users:netboxuser', {'pk': tables.A('pk')})
+ )
+ groups = columns.ManyToManyColumn(
+ linkify_item=('users:netboxgroup', {'pk': tables.A('pk')})
+ )
+ actions = columns.ActionsColumn(
+ actions=('edit', 'delete'),
+ )
+
+ class Meta(NetBoxTable.Meta):
+ model = ObjectPermission
+ fields = (
+ 'pk', 'id', 'name', 'enabled', 'object_types', 'can_view', 'can_add', 'can_change', 'can_delete',
+ 'custom_actions', 'users', 'groups', 'constraints', 'description',
+ )
+ default_columns = (
+ 'pk', 'name', 'enabled', 'object_types', 'can_view', 'can_add', 'can_change', 'can_delete', 'description',
+ )
diff --git a/netbox/users/tests/test_filtersets.py b/netbox/users/tests/test_filtersets.py
index d632687ef..542b40b83 100644
--- a/netbox/users/tests/test_filtersets.py
+++ b/netbox/users/tests/test_filtersets.py
@@ -10,7 +10,6 @@ from users import filtersets
from users.models import ObjectPermission, Token
from utilities.testing import BaseFilterSetTests
-
User = get_user_model()
@@ -34,7 +33,8 @@ class UserTestCase(TestCase, BaseFilterSetTests):
first_name='Hank',
last_name='Hill',
email='hank@stricklandpropane.com',
- is_staff=True
+ is_staff=True,
+ is_superuser=True
),
User(
username='User2',
@@ -83,13 +83,17 @@ class UserTestCase(TestCase, BaseFilterSetTests):
params = {'email': ['hank@stricklandpropane.com', 'dale@dalesdeadbug.com']}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+ def test_is_active(self):
+ params = {'is_active': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+
def test_is_staff(self):
params = {'is_staff': True}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
- def test_is_active(self):
- params = {'is_active': True}
- self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+ def test_is_superuser(self):
+ params = {'is_superuser': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
def test_group(self):
groups = Group.objects.all()[:2]
@@ -191,6 +195,22 @@ class ObjectPermissionTestCase(TestCase, BaseFilterSetTests):
params = {'description': ['foobar1', 'foobar2']}
self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+ def test_can_view(self):
+ params = {'can_view': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+
+ def test_can_add(self):
+ params = {'can_add': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+
+ def test_can_change(self):
+ params = {'can_change': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+
+ def test_can_delete(self):
+ params = {'can_delete': True}
+ self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
+
class TokenTestCase(TestCase, BaseFilterSetTests):
queryset = Token.objects.all()
diff --git a/netbox/users/tests/test_views.py b/netbox/users/tests/test_views.py
new file mode 100644
index 000000000..ca62f474e
--- /dev/null
+++ b/netbox/users/tests/test_views.py
@@ -0,0 +1,151 @@
+from django.contrib.auth.models import Group
+from django.contrib.contenttypes.models import ContentType
+
+from users.models import *
+from utilities.testing import ViewTestCases
+
+
+class UserTestCase(
+ ViewTestCases.GetObjectViewTestCase,
+ ViewTestCases.CreateObjectViewTestCase,
+ ViewTestCases.EditObjectViewTestCase,
+ ViewTestCases.DeleteObjectViewTestCase,
+ ViewTestCases.ListObjectsViewTestCase,
+ ViewTestCases.BulkImportObjectsViewTestCase,
+ ViewTestCases.BulkEditObjectsViewTestCase,
+ ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+ model = NetBoxUser
+ maxDiff = None
+ validation_excluded_fields = ['password']
+
+ def _get_queryset(self):
+ # Omit the user attached to the test client
+ return self.model.objects.exclude(username='testuser')
+
+ @classmethod
+ def setUpTestData(cls):
+
+ users = (
+ NetBoxUser(username='username1', first_name='first1', last_name='last1', email='user1@foo.com', password='pass1xxx'),
+ NetBoxUser(username='username2', first_name='first2', last_name='last2', email='user2@foo.com', password='pass2xxx'),
+ NetBoxUser(username='username3', first_name='first3', last_name='last3', email='user3@foo.com', password='pass3xxx'),
+ )
+ NetBoxUser.objects.bulk_create(users)
+
+ cls.form_data = {
+ 'username': 'usernamex',
+ 'first_name': 'firstx',
+ 'last_name': 'lastx',
+ 'email': 'userx@foo.com',
+ 'password': 'pass1xxx',
+ 'confirm_password': 'pass1xxx',
+ }
+
+ cls.csv_data = (
+ "username,first_name,last_name,email,password",
+ "username4,first4,last4,email4@foo.com,pass4xxx",
+ "username5,first5,last5,email5@foo.com,pass5xxx",
+ "username6,first6,last6,email6@foo.com,pass6xxx",
+ )
+
+ cls.csv_update_data = (
+ "id,first_name,last_name",
+ f"{users[0].pk},first7,last7",
+ f"{users[1].pk},first8,last8",
+ f"{users[2].pk},first9,last9",
+ )
+
+ cls.bulk_edit_data = {
+ 'last_name': 'newlastname',
+ }
+
+
+class GroupTestCase(
+ ViewTestCases.GetObjectViewTestCase,
+ ViewTestCases.CreateObjectViewTestCase,
+ ViewTestCases.EditObjectViewTestCase,
+ ViewTestCases.DeleteObjectViewTestCase,
+ ViewTestCases.ListObjectsViewTestCase,
+ ViewTestCases.BulkImportObjectsViewTestCase,
+ ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+ model = NetBoxGroup
+ maxDiff = None
+
+ @classmethod
+ def setUpTestData(cls):
+
+ groups = (
+ Group(name='group1'),
+ Group(name='group2'),
+ Group(name='group3'),
+ )
+ Group.objects.bulk_create(groups)
+
+ cls.form_data = {
+ 'name': 'groupx',
+ }
+
+ cls.csv_data = (
+ "name",
+ "group4"
+ "group5"
+ "group6"
+ )
+
+ cls.csv_update_data = (
+ "id,name",
+ f"{groups[0].pk},group7",
+ f"{groups[1].pk},group8",
+ f"{groups[2].pk},group9",
+ )
+
+
+class ObjectPermissionTestCase(
+ ViewTestCases.GetObjectViewTestCase,
+ ViewTestCases.CreateObjectViewTestCase,
+ ViewTestCases.EditObjectViewTestCase,
+ ViewTestCases.DeleteObjectViewTestCase,
+ ViewTestCases.ListObjectsViewTestCase,
+ ViewTestCases.BulkEditObjectsViewTestCase,
+ ViewTestCases.BulkDeleteObjectsViewTestCase,
+):
+ model = ObjectPermission
+ maxDiff = None
+
+ @classmethod
+ def setUpTestData(cls):
+ ct = ContentType.objects.get_by_natural_key('dcim', 'site')
+
+ permissions = (
+ ObjectPermission(name='Permission 1', actions=['view', 'add', 'delete']),
+ ObjectPermission(name='Permission 2', actions=['view', 'add', 'delete']),
+ ObjectPermission(name='Permission 3', actions=['view', 'add', 'delete']),
+ )
+ ObjectPermission.objects.bulk_create(permissions)
+
+ cls.form_data = {
+ 'name': 'Permission X',
+ 'description': 'A new permission',
+ 'object_types': [ct.pk],
+ 'actions': 'view,edit,delete',
+ }
+
+ cls.csv_data = (
+ "name",
+ "permission4"
+ "permission5"
+ "permission6"
+ )
+
+ cls.csv_update_data = (
+ "id,name,actions",
+ f"{permissions[0].pk},permission7",
+ f"{permissions[1].pk},permission8",
+ f"{permissions[2].pk},permission9",
+ )
+
+ cls.bulk_edit_data = {
+ 'description': 'New description',
+ }
diff --git a/netbox/users/urls.py b/netbox/users/urls.py
index 7cb1f3435..ca331d144 100644
--- a/netbox/users/urls.py
+++ b/netbox/users/urls.py
@@ -6,15 +6,35 @@ from . import views
app_name = 'users'
urlpatterns = [
- # User
+ # Account views
path('profile/', views.ProfileView.as_view(), name='profile'),
path('bookmarks/', views.BookmarkListView.as_view(), name='bookmarks'),
path('preferences/', views.UserConfigView.as_view(), name='preferences'),
path('password/', views.ChangePasswordView.as_view(), name='change_password'),
-
- # API tokens
path('api-tokens/', views.TokenListView.as_view(), name='token_list'),
path('api-tokens/add/', views.TokenEditView.as_view(), name='token_add'),
path('api-tokens/