Django创建MyModel对象时如何邮件通知用户并获取ManyToManyField

Hey there! I see you're trying to send notifications to all users when a new MyModel instance is created, including all its attributes (even the ManyToManyField), but ran into issues with overriding the save() method. Let's break down why that's happening and fix it step by step.

The core problem here is how Django handles ManyToMany relationships:

• When you first call save() on a new MyModel instance, Django creates the object in the database and generates its primary key. However, the ManyToManyField data isn't saved yet—since those relationships require the object to already exist (to link to its ID).
• If you trigger your notify_users() method inside save(), you'll only get the basic field values, not the associated ManyToMany objects. If you add the ManyToMany data after saving, the email will already have been sent with incomplete info.

If you're creating MyModel instances via a form or view, this is the simplest approach. We'll save the object first, then save the ManyToMany data, and finally trigger the notification once everything is persisted.

Here's an example with a ModelForm:

# views.py
from django.shortcuts import render, redirect
from .forms import MyModelForm
from .models import MyModel

def create_mymodel(request):
    if request.method == 'POST':
        form = MyModelForm(request.POST)
        if form.is_valid():
            # Save the object without committing to DB yet
            mymodel_instance = form.save(commit=False)
            mymodel_instance.save()
            # Now save the ManyToMany relationships
            form.save_m2m()
            # All data (including ManyToMany) is now in the DB—send the email!
            mymodel_instance.notify_users()
            return redirect('success-page')
    else:
        form = MyModelForm()
    return render(request, 'create_mymodel.html', {'form': form})

If you need notifications to trigger no matter how the MyModel instance is created (e.g., via Django admin, scripts, or other views), use Django's built-in signals to listen for when the object and its ManyToMany data are fully saved.

First, create a signals.py file in your app:

# signals.py
from django.db.models.signals import post_save, m2m_changed
from django.dispatch import receiver
from .models import MyModel

@receiver(post_save, sender=MyModel)
def handle_new_mymodel(sender, instance, created, **kwargs):
    if created:
        # If the instance has no ManyToMany data yet, send the email immediately
        if not instance.my_m2m_field.exists():
            instance.notify_users()

@receiver(m2m_changed, sender=MyModel.my_m2m_field.through)
def handle_mymodel_m2m_update(sender, instance, action, **kwargs):
    # Trigger the email only after ManyToMany data is added
    if action == 'post_add' and not hasattr(instance, '_notification_sent'):
        instance.notify_users()
        # Add a temporary flag to avoid duplicate emails
        setattr(instance, '_notification_sent', True)

Then register the signals in your app's apps.py:

# apps.py
from django.apps import AppConfig

class YourAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'your_app_name'

    def ready(self):
        # Import signals to register them
        import your_app_name.signals

Make sure your notify_users method correctly fetches all attributes, including ManyToMany fields. Here's an improved version:

# models.py
from django.db import models
from django.core.mail import send_mail
from django.conf import settings
from django.contrib.auth.models import User

class MyModel(models.Model):
    name = models.CharField(max_length=100)
    my_m2m_field = models.ManyToManyField('OtherModel')
    # Add your other fields here

    def get_full_instance_details(self):
        """Fetch all field values, including ManyToMany relationships"""
        details = {}
        # Get regular fields
        for field in self._meta.fields:
            details[field.name] = getattr(self, field.name)
        # Get ManyToMany fields (convert to readable strings)
        for m2m_field in self._meta.many_to_many:
            related_objects = getattr(self, m2m_field.name).all()
            details[m2m_field.name] = [str(obj) for obj in related_objects]
        return details

    def notify_users(self):
        # Get all users with valid emails
        users = User.objects.filter(email__isnull=False)
        to_emails = [user.email for user in users]

        if not to_emails:
            return  # No emails to send to

        # Build email content
        instance_details = self.get_full_instance_details()
        subject = f"New MyModel Created: {self.name}"
        message = "A new MyModel instance has been created with these details:\n\n"
        for key, value in instance_details.items():
            message += f"{key}: {value}\n"

        # Send the email
        send_mail(
            subject,
            message,
            settings.DEFAULT_FROM_EMAIL,
            to_emails,
            fail_silently=False,
        )

• Email Configuration: Make sure your Django settings.py has email set up correctly (e.g., EMAIL_BACKEND, DEFAULT_FROM_EMAIL, and SMTP details if using an external provider).
• Async Emails: If you have a lot of users, sending emails synchronously will slow down your app. Use a task queue like Celery to handle email sending in the background.
• Avoid Duplicates: The signal solution uses a temporary _notification_sent flag to prevent sending multiple emails if the ManyToMany field is updated multiple times after creation.

内容的提问来源于stack exchange，提问作者Milano