Django 信号

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

# 定义接收者函数
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
"""
当用户被创建时，自动创建用户配置
"""
if created:
    Profile.objects.create(user=instance)
    print(f"为用户 {instance.username} 创建了配置")

# 或者使用 connect 方法手动连接
def log_user_save(sender, instance, **kwargs):
print(f"用户 {instance.username} 被保存")

post_save.connect(log_user_save, sender=User)

# 信号发送的基本语法
signal.send(sender, **kwargs)

# 常见信号参数：
# - sender: 发送信号的对象类
# - instance: 相关的模型实例
# - created: 是否是新建对象 (post_save)
# - raw: 是否是原始数据库加载
# - using: 使用的数据库别名
# - update_fields: 更新的字段列表
# - **kwargs: 其他参数

# 接收者函数签名
def my_receiver(sender, **kwargs):
# sender: 发送者的类
# kwargs: 其他信号参数
pass

from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from myapp.models import MyModel

# 基本用法
@receiver(post_save, sender=MyModel)
def my_handler(sender, instance, **kwargs):
print(f"{instance} 被保存了")

# 连接多个信号
@receiver([post_save, pre_delete], sender=MyModel)
def multi_signal_handler(sender, **kwargs):
if sender == post_save:
    print("保存操作")
elif sender == pre_delete:
    print("删除操作")

# 带条件的信号处理
@receiver(post_save, sender=MyModel)
def conditional_handler(sender, instance, created, **kwargs):
if created:
    print("新对象被创建")
else:
    print("现有对象被更新")

# 使用 dispatch_uid 避免重复连接
@receiver(post_save, sender=MyModel, dispatch_uid="my_unique_handler")
def unique_handler(sender, instance, **kwargs):
print("这个处理程序只会被连接一次")

from django.db.models.signals import post_save
from myapp.models import MyModel

def manual_handler(sender, instance, **kwargs):
print(f"手动处理: {instance}")

# 手动连接信号
post_save.connect(manual_handler, sender=MyModel)

# 使用 weak=False 避免垃圾回收
post_save.connect(manual_handler, sender=MyModel, weak=False)

# 使用 dispatch_uid
post_save.connect(
manual_handler,
sender=MyModel,
dispatch_uid="manual_handler_unique"
)

# 断开信号连接
post_save.disconnect(manual_handler, sender=MyModel)
# 或者使用 dispatch_uid 断开
post_save.disconnect(dispatch_uid="manual_handler_unique")

# 临时连接（使用后自动断开）
from django.dispatch import Signal

def temp_handler(sender, **kwargs):
print("临时处理程序")
# 执行后自动断开
some_signal.disconnect(temp_handler)

some_signal.connect(temp_handler)

# myapp/apps.py
from django.apps import AppConfig

class MyAppConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'myapp'

def ready(self):
    # 导入信号处理程序
    import myapp.signals

# myapp/signals.py
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from .models import MyModel

@receiver(post_save, sender=MyModel)
def handle_post_save(sender, instance, **kwargs):
# 处理保存后逻辑
pass

@receiver(pre_delete, sender=MyModel)
def handle_pre_delete(sender, instance, **kwargs):
# 处理删除前逻辑
pass

from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import AuditLog

@receiver(post_save, sender=User)
def log_user_change(sender, instance, created, **kwargs):
"""
记录用户模型的变更
"""
action = 'create' if created else 'update'

AuditLog.objects.create(
    model_name='User',
    object_id=instance.id,
    action=action,
    changes={
        'username': instance.username,
        'email': instance.email,
        'is_active': instance.is_active
    },
    user=get_current_user()  # 需要实现这个函数
)

@receiver(post_delete, sender=User)
def log_user_delete(sender, instance, **kwargs):
"""
记录用户删除
"""
AuditLog.objects.create(
    model_name='User',
    object_id=instance.id,
    action='delete',
    changes={
        'username': instance.username,
        'email': instance.email
    },
    user=get_current_user()
)

from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from django.core.cache import cache
from .models import Product

@receiver([post_save, post_delete], sender=Product)
def clear_product_cache(sender, **kwargs):
"""
产品数据变更时清理缓存
"""
cache_keys = [
    'featured_products',
    'product_categories',
    'product_stats'
]

for key in cache_keys:
    cache.delete(key)

print("产品缓存已清理")

from django.db.models.signals import post_save, m2m_changed
from django.dispatch import receiver
from .models import Order, OrderItem, Inventory

@receiver(post_save, sender=OrderItem)
def update_order_total(sender, instance, **kwargs):
"""
更新订单项时重新计算订单总额
"""
order = instance.order
order.total = sum(item.subtotal for item in order.items.all())
order.save(update_fields=['total'])

@receiver(m2m_changed, sender=Order.items.through)
def update_inventory(sender, instance, action, **kwargs):
"""
订单项变更时更新库存
"""
if action in ['post_add', 'post_remove', 'post_clear']:
    for item in instance.items.all():
        inventory = Inventory.objects.get(product=item.product)
        if action == 'post_add':
            inventory.quantity -= item.quantity
        elif action == 'post_remove':
            inventory.quantity += item.quantity
        inventory.save()

from django.db.models.signals import post_save
from django.dispatch import receiver
from django.core.mail import send_mail
from .models import Comment, Notification

@receiver(post_save, sender=Comment)
def notify_comment(sender, instance, created, **kwargs):
"""
新评论时发送通知
"""
if created:
    # 创建站内通知
    Notification.objects.create(
        user=instance.post.author,
        title="新评论",
        message=f"{instance.author} 评论了您的文章",
        target_url=instance.post.get_absolute_url()
    )

    # 发送邮件通知（如果是重要评论）
    if instance.post.author.email_notifications:
        send_mail(
            subject=f"您收到了新评论 - {instance.post.title}",
            message=f"{instance.author} 在您的文章中评论: {instance.content}",
            from_email='noreply@example.com',
            recipient_list=[instance.post.author.email],
            fail_silently=True
        )