Gruppen und Berechtigungen des Django-Benutzerauthentifizierungssystems (3).

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:

Name: erforderlich, 80 Zeichen oder weniger, zum Beispiel „Tolle Benutzer“.

permissions：ManyToManyField to Permission

group.permissions = [permission_list]

group.permissions.add(permission,mission, ...)

group.permissions.remove( Erlaubnis, Erlaubnis, ...)

group.permissions.clear()


Programmgesteuertes Erstellen von Berechtigungen

Zusätzlich zur Verwendung von Modellmeta zum Erstellen von Berechtigungen können Sie auch verwenden Code direkt erstellen.

Erstellen Sie beispielsweise eine can_publish-Berechtigung für das BlogPost-Modell in der myapp-Anwendung:

from myapp.models import BlogPost

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.

Berechtigungs-Caching

Benutzerberechtigungen können bei der Überprüfung zwischengespeichert werden. Wenn einem Benutzer eine neue Berechtigung erteilt wird, wird diese nicht überprüft, wenn sie sofort überprüft wird. Der einfachste Weg besteht darin, das Benutzerobjekt erneut abzurufen.

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])

Überprüft, ob der Benutzer eine bestimmte Berechtigung hat, ähnlich wie @login_required()

von django.contrib.auth.decorators Import Permission_required

@permission_required('polls.can_vote', login_url='/loginpage/')

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.

{{ perms.foo }}

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:

{% if perms.foo %}

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.
{% 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)!