Compétences en gestion multi-utilisateurs dans le framework Django (Partie 2)

Compétences en gestion multi-utilisateurs dans le framework Django (Partie 2)

Dans l'article précédent, nous avons présenté comment implémenter la gestion multi-utilisateurs dans le framework Django. Cet article continuera à partager davantage de conseils et de bonnes pratiques pour aider les développeurs à mieux gérer les scénarios multi-utilisateurs.

1. Utilisez le propre système d'autorisation de Django

Django fournit un système d'autorisation intégré qui peut facilement implémenter la gestion des autorisations des utilisateurs. Définissez le modèle d'autorisation dans models.py :

from django.contrib.auth.models import Permission, User

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)

    class Meta:
        permissions = [
            ("can_publish", "Can publish posts"),
        ]

Le code ci-dessus définit un modèle Post, et chaque article a un auteur. Une permission est définie dans la classe Meta, nommée "can_publish", ce qui signifie que l'utilisateur peut publier des articles.

Dans la fonction d'affichage, vous pouvez vérifier si l'utilisateur dispose d'une certaine autorisation comme ceci :

from django.contrib.auth.decorators import permission_required

@permission_required('blog.can_publish')
def publish_post(request):
    # 发布文章的逻辑

2. Utilisez Django-guardian pour améliorer la gestion des autorisations

Le système d'autorisation de Django est intégré, mais il est difficile à utiliser avec gestion des autorisations au niveau de l'objet. Django-guardian est une bibliothèque tierce qui permet un contrôle plus fin des autorisations au niveau de l'objet. Pour utiliser Django-guardian, vous devez définir un modèle d'autorisation dans models.py :

from django.contrib.auth.models import User
from django.db import models
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey

class Post(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)

class PostPermission(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    can_edit = models.BooleanField(default=False)

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)

    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

Le code ci-dessus définit un modèle Post, et chaque article a un auteur. Dans le même temps, un modèle PostPermission est défini pour représenter les autorisations d'édition de l'utilisateur pour un certain article. En utilisant l'API de Django-guardian, les utilisateurs peuvent être autorisés à modifier un certain article :

from django.contrib.auth.models import User
from blog.models import Post, PostPermission
from guardian.shortcuts import assign_perm

user = User.objects.get(username='testuser')
post = Post.objects.get(id=1)
assign_perm('can_edit', user, post)

3. Restreindre les utilisateurs à mettre à jour leurs propres informations

Dans les applications qui gèrent plusieurs utilisateurs, il est parfois nécessaire de restreindre les utilisateurs à mettre à jour uniquement les leurs. informations informations. Par exemple, un site de réseautage social doit restreindre les utilisateurs à mettre à jour uniquement leurs propres informations personnelles et à ne pas modifier les informations d'autres personnes. La vérification des autorisations peut être implémentée dans la fonction d'affichage :

from django.contrib.auth.decorators import login_required
from django.shortcuts import render, get_object_or_404
from blog.models import Profile

@login_required
def update_profile(request, pk):
    profile = get_object_or_404(Profile, pk=pk)
    if request.user != profile.user:
        return render(request, 'profile_error.html')

    if request.method == 'POST':
        # 更新用户资料逻辑
    else:
        # 返回更新资料页面

Le code ci-dessus vérifie d'abord si l'utilisateur est connecté, puis obtient que l'instance de profil soit mise à jour en fonction de la clé primaire. Après avoir vérifié si l'utilisateur est le propriétaire du profil, sinon, affichez une page d'erreur. S'il s'agit du propriétaire, affichez la page de mise à jour.

Conclusion

Grâce à l'introduction de cet article, nous avons appris à mieux gérer les scénarios multi-utilisateurs dans le framework Django. Les autorisations des utilisateurs peuvent être facilement gérées à l'aide du système d'autorisation intégré, tandis que Django-guardian peut obtenir un contrôle plus précis des autorisations au niveau des objets. Enfin, empêcher les utilisateurs de mettre à jour leurs propres informations peut améliorer la sécurité des applications et l'expérience utilisateur. J'espère que ces conseils vous inspireront dans votre développement Django.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!