在 post_save 信号中访问用户的请求

Question

我在我的项目中完成了以下 post_save 信号。

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

operation_by 列，我想获取 user_id 并存储它。知道如何做到这一点吗？

Answer 1

做不到。当前用户只能通过请求获得，这在使用纯模型功能时不可用。以某种方式访问​​视图中的用户。

Answer 2

您可以借助中间件来做到这一点。在您的应用中创建 get_request.py。然后

from threading import current_thread

from django.utils.deprecation import MiddlewareMixin


_requests = {}


def current_request():
    return _requests.get(current_thread().ident, None)


class RequestMiddleware(MiddlewareMixin):

    def process_request(self, request):
        _requests[current_thread().ident] = request

    def process_response(self, request, response):
        # when response is ready, request should be flushed
        _requests.pop(current_thread().ident, None)
        return response


    def process_exception(self, request, exception):
        # if an exception has happened, request should be flushed too
         _requests.pop(current_thread().ident, None)

将此中间件添加到您的设置中：

MIDDLEWARE = [
    ....
    '<your_app>.get_request.RequestMiddleware',
]

然后将导入添加到您的信号中：

from django.db.models.signals import post_save
from django.contrib.auth.models import User
from <your_app>.get_request import current_request

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

def after_save_handler_attr_audit_obj(sender, **kwargs):
    print(Current User, current_request().user)
    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")

Answer 3

我可以通过检查堆栈并查找视图，然后查看视图的局部变量来获取请求。感觉有点像黑客，但它确实有效。

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

Answer 4

伊格纳西奥是对的。 Django 的模型信号旨在通知其他系统组件有关与实例及其相关数据相关的事件，因此我认为您不能从模型 post_save 信号访问请求数据是有效的，除非该请求数据存储在实例上或与实例关联。

我想有很多方法可以处理它，从更坏到更好，但我想说这是创建基于类/基于函数的通用视图的一个主要示例，该视图将自动处理这个问题为你。

让继承自 CreateView、UpdateView 或 DeleteView 的视图另外继承自 AuditMixin 类（如果它们处理以下动词）对需要审核的模型进行操作。然后，AuditMixin 可以挂钩到成功创建\更新\删除对象并在数据库中创建条目的视图。

非常有意义，非常干净，易于插拔，并孕育出快乐的小马。反面？您要么必须使用即将发布的 Django 1.3 版本，要么必须花一些时间调整基于函数的通用视图并为每个审核操作提供新的视图。

Answer 5

为什么不添加一个中间件，如下所示：

class RequestMiddleware(object):

    thread_local = threading.local()

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

然后在您的代码中（特别是在该主题中的信号中）：

thread_local = RequestMiddleware.thread_local
if hasattr(thread_local, 'current_user'):
    user = thread_local.current_user
else:
    user = None

Answer 6

为了可追溯性，向您的模型添加两个属性（created_by 和 updated_by），在“updated_by”中保存最后修改记录的用户。然后在您的信号中您有用户：

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

Answer 7

您也可以使用 django-reversion 来实现此目的，例如，

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

阅读有关其 API 的更多信息 https://django-reversion.readthedocs.io/en/stable/api.html#revision-api

Answer 8

您可以通过重写模型 save() 方法并将保存的实例上的用户设置为附加参数来进行小修改。为了获取用户，我使用了 django_currentuser.middleware.ThreadLocalUserMiddleware 中的 get_current_authenticated_user() （参见 https://pypi.org/project/django-currentuser/）。

在您的 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)

在您的 signals.py 中：

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

PS：不要忘记将 'django_currentuser.middleware.ThreadLocalUserMiddleware' 添加到您的MIDDLEWARE_CLASSES。

Answer 9

我想您应该已经弄清楚了这一点，但我遇到了同样的问题，并且我意识到我创建的所有实例都引用了创建它们的用户（这就是您正在寻找的）

Answer 10

我猜有可能。

在models.py中

class _M(models.Model):
    user = models.ForeignKey(...)

在views.py中

def _f(request):
    _M.objects.create(user=request.user)

在signals.py中

@receiver(post_save, sender=_M)
def _p(sender, instance, created, **kwargs):
   user = instance.user

否？

Answer 11

可以通过检查从帧记录中获取请求对象。

import inspect

request = [
    frame_record[0].f_locals["request"]
    for frame_record in inspect.stack()
    if frame_record[3] == "get_response"
][0]

Answer 12

def get_requested_user():
    import inspect
    for frame_record in inspect.stack():
        if frame_record[3] == 'get_response':
            request = frame_record[0].f_locals['request']
            return request.user
    else:
        return None

Answer 13

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',
)