Accédant à la demande de l'utilisateur dans un post_save signal

Je l'ai fait ci-dessous post_save signal dans mon projet. 

from django.db.models.signals import post_save
from django.contrib.auth.models import User

# CORE - SIGNALS
# Core Signals will operate based on post

def after_save_handler_attr_audit_obj(sender, **kwargs):
    print User.get_profile()

    if hasattr(kwargs['instance'], 'audit_obj'):
        if kwargs['created']:
            kwargs['instance'].audit_obj.create(operation="INSERT", operation_by=**USER.ID**).save()
        else:
            kwargs['instance'].audit_obj.create(operation="UPDATE").save()


# Connect the handler with the post save signal - Django 1.2
post_save.connect(after_save_handler_attr_audit_obj, dispatch_uid="core.models.audit.new")

La operation_by colonne, je veux obtenir le user_id et de les stocker. Aucune idée de comment faire?

  • Il ya une raison pourquoi django ne veut pas que vous demande d'accès à l'objet dans les modèles et les signaux. Sa philosophie de la séparation des préoccupations seront violés.
InformationsquelleAutor Mo J. Mughrabi | 2011-01-17
  1. 25

    Ne peut pas être fait. L'utilisateur actuel n'est disponible que via la demande, ce qui n'est pas disponible lors de l'utilisation purement fonctionnalités du modèle. Accès de l'utilisateur dans la vue en quelque sorte.

    • hmm Il un sens, je viens de reformater ma question de trouver un moyen de faire le travail à l'aide d'autres méthodes
    • stackoverflow.com/questions/4725685/...
    • Vous pouvez le faire lors du chargement de votre point de vue. Dans votre post_save enregistrer l'état que vous souhaitez marquer dans le modèle. Lors du chargement du modèle dans la vue, de vérifier l'état du pavillon et faites ce que vous voulez avec elle avant réponse. Je fais un appel api post statut, puis définissez un modèle de champ appelé api_status avec le code d'état. J'ai vérifier le code dans mon obtenir et d'utiliser les messages de cadre à en informer l'utilisateur de l'état a reçu à partir de l'appel.
    • Je suis à l'aide de post_save. Le modèle qui est de l'enregistrement des données a un champ appelé user. Je suis à l'aide de instance.user pour cible l'utilisateur. Toutefois, la condition est qu'aucun utilisateur ne peut modifier d'autres utilisateurs les instances. Ainsi, l'utilisateur connecté est égale à la instance.user valeur.
    InformationsquelleAutor Ignacio Vazquez-Abrams
  2. 14

    J'ai été capable de le faire par l'inspection de la pile et de la recherche de la vue, puis en regardant les variables locales de la vue de la demande. Il se sent comme un peu un hack, mais cela a fonctionné.

    import inspect, os

@receiver(post_save, sender=MyModel)
def get_user_in_signal(sender, **kwargs):
    for entry in reversed(inspect.stack()):
        if os.path.dirname(__file__) + '/views.py' == entry[1]:
            try:
                user = entry[0].f_locals['request'].user
            except:
                user = None
            break
    if user:
        # do stuff with the user variable
    • a très bien fonctionné pour moi, je ne savais pas que le point de vue serait donc j'ai supprimé cette case et il fonctionnait encore très bien.
    • Ce n'est pas "de droite", mais il fonctionne très bien, donc je pense que c'est la bonne réponse.
    InformationsquelleAutor PaulR
  3. 7

    Ignacio est droit. Django du modèle signaux sont destinés à informer les autres composants du système sur les événements associés avec les instances et respectée des données, donc je suppose que c'est valide que vous ne pouvez pas, dire, demande d'accès aux données à partir d'un modèle post_save signal, à moins que la demande de données est stockée sur ou associée à l'instance.

    Je suppose qu'il ya beaucoup de façons de le gérer, allant du pire au meilleur, mais je dirais que c'est un premier exemple pour la création de la classe de base/fonction générique de points de vue qui permettra de gérer automatiquement pour vous.

    Avoir votre point de vue qui héritent de CreateView, UpdateView ou DeleteView en outre hériter de votre AuditMixin classe, si ils gèrent les verbes qui fonctionnent sur des modèles qui doivent être audités. Le AuditMixin pouvez ensuite le crochet dans le point de vue qui a réussi à créer\update\supprimer des objets et créer une entrée dans la base de données.

    Sens parfait, très propre, facilement connectable et donne naissance à heureux poneys. Revers de médaille? Vous devrez être sur le bientôt-à-être-publié Django version 1.3 ou vous aurez à passer un peu de temps fiddlebending la fonction générique de vues et de fournir de nouvelles, pour chaque audit de l'opération.

    InformationsquelleAutor Filip Dupanović
  4. 5

    Pour la traçabilité ajouter deux attributs à votre Modèle(created_by et updated_by), dans "updated_by" enregistrer le dernier utilisateur qui a modifié l'enregistrement. Puis dans votre signal que vous avez à l'utilisateur:

    models.py:

    class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')
    created_by = models. (max_length=100)
    updated_by = models. (max_length=100)

    views.py

        p = Question.objects.get(pk=1)
    p.question_text = 'some new text'
    p.updated_by = request.user
    p.save()

    signals.py

    @receiver(pre_save, sender=Question)
def do_something(sender, instance, **kwargs):
    try:
        obj = Question.objects.get(pk=instance.pk)
    except sender.DoesNotExist:
        pass
    else:
        if not obj.user == instance.user: # Field has changed
            # do something
            print('change: user, old=%s new=%s' % (obj.user, instance.user))
    • C'est terriblement tendance à des conditions de course. Qui pourrait être ok pour un grand nombre de cas d'utilisation, mais il devrait être mentionné.
    InformationsquelleAutor ALEXANDER GOMEZ HIGUITA
  5. 5

    Vous pouvez également utiliser django-réversion à cette fin, par exemple 

    from reversion.signals import post_revision_commit
import reversion

@receiver(post_save)
def post_revision_commit(sender, **kwargs):
    if reversion.is_active():
        print(reversion.get_user())

    Lire plus sur leur API https://django-reversion.readthedocs.io/en/stable/api.html#revision-api

    InformationsquelleAutor bjorn
  6. 4

    Pourquoi ne pas ajouter un middleware avec quelque chose comme ceci :

    class RequestMiddleware(object):

    thread_local = threading.local()

    def process_request(self, request):
        RequestMiddleware.thread_local.current_user = request.user

    et plus loin dans votre code (spécialement dans un signal dans le sujet) :

    thread_local = RequestMiddleware.thread_local
if hasattr(thread_local, 'current_user'):
    user = thread_local.current_user
else:
    user = None
    • Sons propre approche. Je veux savoir comment cher est ce.
    • Je vous déconseillons d'utiliser le filetage pour cela. C'est se sentir très hacky, et n'est pas du niveau d'application du code, puisque vous n'avez pas beaucoup de contrôle de ces fils. Je voudrais utiliser le cache comme une communication backend ici à l'aide d'un ID unique.
    • avez-vous de savoir comment revient-il cher? Je pense que je vais la mettre en œuvre aussi bien, et pour l'instant je ne peux pas penser à des effets secondaires.
    • Je l'ai utilisé, fonctionne mal. Probablement que c'est parce que l'un thread peut traiter plusieurs demandes.
    InformationsquelleAutor firebird631
  7. 1

    J'imagine que vous avez compris cela, mais j'ai eu le même problème et j'ai réalisé que tous les cas, j'ai créer avait une référence à l'utilisateur qui les crée (qui est ce que vous cherchez)

    • Pourriez-vous élaborer? Comment venir:"tous les cas, j'ai créer avait une référence à l'utilisateur qui les a créés"?
    • Ce que je veux dire, c'est que tous les signaux-je utiliser la référence à une instance (dans le kwargs) qui a un champ 'created_by' ou quelque chose de similaire, qui fait référence à l'utilisateur.
    InformationsquelleAutor kiril
  8. -1
    context_processors.py

from django.core.cache import cache

def global_variables(request):
    cache.set('user', request.user)

----------------------------------
in you model

from django.db.models.signals import pre_delete
from django.dispatch import receiver
from django.core.cache import cache
from news.models import News

@receiver(pre_delete, sender=News)
def news_delete(sender, instance, **kwargs):
    user = cache.get('user')

in settings.py

TEMPLATE_CONTEXT_PROCESSORS = (
    'web.context_processors.global_variables',
)
    • Une description de ce que vous avez fait là serait utile.
    • C'est une très mauvaise idée, de ne jamais le faire de cette façon. Avec la plupart des configurations de cache ça va mener à condition de course.
    • Ce qui est totalement FAUX. le cache n'est pas de demande spécifique
    • Juste une remarque, ce n'est pas nécessairement une mauvaise idée si vous donnez un identifiant unique comme une clé. Mon cas d'utilisation est d'ajouter des méta-données à partir de la demande à une instance qui est créé par un signal, mais a besoin de données à partir de la demande. Je n'aime pas l'idée de couplage avec un processus spécifique. Je voudrais utiliser les utilisateurs PK champ user_{pk} et accès aux métadonnées. cela ne devrait pas créer une situation de concurrence, et donne le résultat escompté.
    InformationsquelleAutor Николай Сибилёв
  9. -2

    Vous pouvez faire un petit hack en remplaçant le modèle de save() méthode et le paramétrage de l'utilisateur sur le sauvé instance comme paramètre supplémentaire. Pour obtenir de l'utilisateur, j'ai utilisé get_current_authenticated_user() de django_currentuser.middleware.ThreadLocalUserMiddleware (voir https://pypi.org/project/django-currentuser/).

    Dans votre models.py:

    from django_currentuser.middleware import get_current_authenticated_user

class YourModel(models.Model):
    ...
    ...

    def save(self, *args, **kwargs):
        # Hack to pass the user to post save signal.
        self.current_authenticated_user = get_current_authenticated_user()
        super(YourModel, self).save(*args, **kwargs)

    Dans votre signals.py:

    @receiver(post_save, sender=YourModel)
def your_model_saved(sender, instance, **kwargs):
    user = getattr(instance, 'current_authenticated_user', None)

    PS: N'oubliez pas d'ajouter 'django_currentuser.middleware.ThreadLocalUserMiddleware' à votre MIDDLEWARE_CLASSES.

    • Qui se sent trop hacky et apparaît comme la magie noire dans l'autre application qui utilise le signal (l'accès à un champ qui n'existe pas dans la définition du modèle).
    • Que sont les mots à partir de laquelle le message commence: "Vous pouvez faire un petit hack". Hack est hack, il permet de résoudre certains problème. Juste être prudent avec elle ou trouver d'améliorer la sécurité de la solution.
    InformationsquelleAutor Yaroslav Varkhol