Django: Check on type of relation a form has

Question

I have a situation where I need to check if a form has m2m relation before saving it in views.py as I am using the same views.py for different models.

Example:

#models.py
class BaseClass(models.Model):
   # Some generic stuff.

class SomeClass(BaseClass):
   # This class doesnt have any many2many relations

class SomeOtherClass(BaseClass):
   # This class has many2many relations

#views.py
def do_some_stuff(request):
   # Instantiate a form
   # Save it in a normal way
   form.save()
   # Now, in here while saving I need to check if the form has any 
   # m2m relations so I can use the save_m2m() function after form.save()

I just need an extra check in there to be on the safer side. Is there any way around this? Thanks in advance

Answer 1

if hasattr(form, 'save_m2m'):
    form.save_m2m()

You should bear in mind that save_m2m is only necessary (and only exists) when you call form.save with commit=False argument. If you save it with commit=True which is the default, there's no need in save_m2m.

Answer 2

I just figured out the probable solution for this.

You could use something like this:

if len(form_instance._meta.many_to_many) > 0:
   for i in form_instance._meta.many_to_many:
      if type(i) = ManyToManyField:
         form_instance.save_m2m()
         break

Answer 3

Antony is right and it is even easier, I quote from the documentation:

Another side effect of using commit=False is seen when your model has a many-to-many relation with another model. If your model has a many-to-many relation and you specify commit=False when you save a form, Django cannot immediately save the form data for the many-to-many relation. This is because it isn't possible to save many-to-many data for an instance until the instance exists in the database.

To work around this problem,every time you save a form using commit=False, Django adds a save_m2m() method to your ModelForm subclass.

According to that, if you don't save a form with commit=False the method save_m2m() does not even exist, no matter if many-to-many relationships exist.

True to the Python motto "easier to ask forgiveness than permission" you can also do:

try:
    form.save_m2m()
except:
    pass

if you really want to.

Answer 4

In fact, save_m2m() is always injected into ModelForm instance after save(commit=False). Even if there're no ManyToMany fields in the model.

Here's the source of save_m2m function:

def save_m2m():
    opts = instance._meta
    cleaned_data = form.cleaned_data
    for f in opts.many_to_many:
        if fields and f.name not in fields:
            continue
        if f.name in cleaned_data:
            f.save_form_data(instance, cleaned_data[f.name])

If there are no ManyToMany fields (instance._meta.many_to_many=[]) nothing will be done.

So you can safely call save_m2m in all cases.