Djangos Berechtigungssystem ist sehr einfach, es kann Benutzern oder Benutzern in Gruppen Berechtigungen erteilen.
Das Django-Administrator-Backend verwendet dieses Berechtigungssystem, es kann aber auch in Ihrem eigenen Code verwendet werden.
Benutzerobjekt verfügt über zwei ManyToManyField-Felder, Gruppen und Benutzerberechtigungen
groups = models.ManyToManyField(Group, verbose_name=_('groups'),
blank=True, help_text=_ ( 'Die Gruppen, denen dieser Benutzer angehört. '
name="user_set", related_query_name="user")
user_permissions = models.ManyToManyField(Permission,
verbose_name=_('Benutzerberechtigungen') , blank=True,
help_text=_('Spezifische Berechtigungen für diesen Benutzer.'),
related_name= "user_set", related_query_name="user")
Sie können darauf zugreifen wie andere Django-Modelle:
myuser.groups = [group_list]
myuser.groups. add(group, group, ...)myuser.groups.remove(group, group, .. .)
myuser.groups.clear()
myuser.user_permissions = [permission_list]
myuser.user_permissions.add(permission,mission, ...)
myuser.user_permissions.remove(permission, Berechtigung, ...)
myuser.user_permissions.clear()
Berechtigungen
Berechtigung existiert als Modell, indem eine Instanz der Berechtigung erstellt wird Modell.
@python_2_unicode_kompatible
Klassenberechtigung(models.Model): """
Das Berechtigungssystem bietet eine Möglichkeit, bestimmten
Benutzern und Benutzergruppen Berechtigungen zuzuweisen.
Das Berechtigungssystem wird von der Django-Administratorseite verwendet, kann aber auch in Ihrem eigenen Code nützlich sein. Die Django-Administratorseite verwendet Berechtigungen wie folgt:
– Die „Hinzufügen“-Berechtigungsgrenzen die Möglichkeit des Benutzers, das Formular „Hinzufügen“ anzuzeigen
und ein Objekt hinzuzufügen.
– Die Berechtigung „Löschen“ schränkt die Möglichkeit ein, ein Objekt zu löschen.
Berechtigungen werden global pro Objekttyp festgelegt , nicht pro spezifischem Objekt
Instanz. Es ist möglich zu sagen „Mary kann Nachrichtenmeldungen ändern“, aber es ist
derzeit nicht möglich zu sagen „Mary kann Nachrichtenmeldungen ändern, aber nur die
die, die sie selbst erstellt hat.“ „ oder „Mary darf nur Nachrichten ändern, die einen
bestimmten Status oder Veröffentlichungsdatum haben.“
Drei Grundberechtigungen – Hinzufügen, Ändern und Löschen – werden automatisch
für jedes Django-Modell erstellt .
"""
name = models.CharField(_( 'name'), max_length=255)
content_type = models.ForeignKey(ContentType)
codename = models.CharField(_(' codename'), max_length=100)
Objekte = PermissionManager()
Klassenmeta:
verbose_name = _('permission')
verbose_name_plural = _('permissions')
unique_together = (('content_type', 'codename'),)
order ing = ('content_type__app_label', 'content_type__model',
verwenden verwenden verwenden verwenden verwenden use using ' using ' s using text_type(self.content_type.app_label) to self.codename,) + self.content_type.natural_key()
natural_key.dependencies = ['contenttypes.contenttype']
Felder Felder
Name: erforderlich. 50 Zeichen oder weniger, zum Beispiel „Kann abstimmen“
content_type: Erforderlich, ein Verweis auf die Datenbanktabelle django_content_type, die Datensätze für jedes Modell in der Anwendung enthält.
Codename: erforderlich, 100 Zeichen oder weniger, z. B. „can_vote“.
Wenn Sie Berechtigungen für ein Modell erstellen möchten:
aus django.db Modelle importieren
Klassenabstimmung (Modelle.Modell):
...
Klassenmeta:
permissions = (("can_vote", "Can Vote"),)
Wenn sich dieses Modell in der Anwendung foo befindet, werden die Berechtigungen als „foo“ ausgedrückt. can_vote', prüfen Sie, ob ein Benutzer Berechtigungen hat myuser.has_perm('foo.can_vote')
Standardberechtigungen Standardberechtigungen
Wenn django.contrib.auth in INSTALLED_APPS konfiguriert wurde, ist dies der Fall Garantiert: Jedes Django-Modell in installierten Anwendungen erstellt 3 Standardberechtigungen: Hinzufügen, Ändern und Löschen.
Diese Berechtigungen werden erstellt, wenn Sie manage.py migrate (syncdb vor 1.7) zum ersten Mal ausführen. Zu diesem Zeitpunkt werden für alle Modelle Berechtigungen eingerichtet. Für neue Modelle, die danach erstellt werden, werden diese Standardberechtigungen erstellt, wenn manage.py migrate erneut ausgeführt wird. Diese Berechtigungen entsprechen dem Erstellungs-, Lösch- und Änderungsverhalten in der Admin-Verwaltungsoberfläche.
Angenommen, Sie haben eine Anwendung foo mit einer Modellleiste, können Sie die folgende Methode verwenden, um grundlegende Berechtigungen zu testen:
add: user.has_perm('foo.add_bar')
change : user.has_perm('foo.change_bar')
löschen: user.has_perm('foo.delete_bar')
Das Berechtigungsmodell wird im Allgemeinen nicht direkt verwendet.
Gruppen
Gruppe existiert auch als Modell:
@python_2_unicode_kompatible
Klassengruppe(models.Model):
"""
Gruppen sind eine generische Methode zum Kategorisieren von Benutzern, um diesen Benutzern Berechtigungen oder
eine andere Bezeichnung zuzuweisen. Ein Benutzer kann einer beliebigen Anzahl von
Gruppen angehören.
Ein Benutzer in einer Gruppe verfügt automatisch über alle Berechtigungen, die dieser Gruppe gewährt werden
Wenn beispielsweise die Gruppe „Site-Editoren“ über die Berechtigung „can_edit_home_page“ verfügt, verfügt jeder Benutzer in dieser Gruppe über diese Berechtigung.
Über Berechtigungen hinaus sind Gruppen eine bequeme Möglichkeit, dies zu tun Kategorisieren Sie Benutzer, um
ihnen eine Bezeichnung oder erweiterte Funktionalität zuzuweisen. Sie können beispielsweise eine Gruppe „Spezielle Benutzer“ erstellen und Code schreiben, der diesen Benutzern besondere Aktionen vornimmt. - indem Sie ihnen beispielsweise Zugriff auf einen
nur für Mitglieder zugänglichen Teil Ihrer Website gewähren oder ihnen E-Mail-Nachrichten
nur für Mitglieder senden.
"""
name = models.CharField(_(' name '), max_length=80, unique=True)
Berechtigungen = models.ManyToManyField(Permission,
verbose_name=_('permissions'), blank=True)
Objekte = GroupManager()
class Meta:
verbose_name = _('group')
verbose_name_plural = _('groups')
def __str__(self):
return self.name
def natural_key(self):
return (self.name,)
Felder:
group.permissions.add(permission,mission, ...)
group.permissions.remove( Erlaubnis, Erlaubnis, ...)group.permissions.clear()
Programmgesteuertes Erstellen von Berechtigungen
from django.contrib.auth.models import Group, Permission
from django.contrib.contenttypes.models import ContentType
content_type = ContentType.objects.get_for_model(BlogPost)
permission = Permission.objects.create(codename='can_publish',
name= 'Kann Beiträge veröffentlichen',
Content_type = Content_type)
Berechtigungen können einem Benutzerobjekt über seine user_permissions oder einer Gruppe über sein Permissions-Attribut erteilt werden.
from django.contrib.auth.models import Permission, User
from django.shortcuts import get_object_or_404
def user_gains_perms(request, user_id):
user = get_object_or_404(User, pk=user_id ). .user_permissions.add(permission)
# Berechtigungscachesatz prüfen
user.has_perm('myapp.change_bar') # False
# Neue Instanz anfordern
user = get_object_or_404( Benutzer, pk=user_id)
# Berechtigungscache wird aus der Datenbank neu aufgefüllt
user.has_perm('myapp.change_bar') # True
...
Permission Decorator
permission_required(perm[, login_url=None, raise_Exception=False])
def my_view(request):
…
Berechtigungen in der Vorlage
Die Berechtigungen des Benutzers werden in der Vorlagenvariablen {{ perms }} gespeichert, die eine Instanz von django.contrib.auth.context_processors.PermWrapper ist.
Das obige einzelne Attribut ist der Proxy von User.has_module_perms. Wenn der Benutzer eine Berechtigung in foo hat, ist diese wahr
{{ perms.foo.can_vote }}
Die obige zweistufige Attributabfrage ist der Proxy von User.has_perm, True, wenn der Benutzer über die Berechtigung foo.can_vote verfügt.
Zum Beispiel:
Sie haben die Berechtigung, etwas in der foo-App zu tun.
{ % if perms.foo.can_vote %}
Sie können abstimmen!
p>Sie können fahren! {% endif %}
{% else %}
Sie haben keine Berechtigung, irgendetwas in der foo-App zu tun.< /p>
{% endif %}
oder:
{% if 'foo' in perms %}
{% if 'foo.can_vote' in perms. %}
Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www .php.cn)!
