Maison > Article > développement back-end > 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.
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): # 发布文章的逻辑
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)
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!