python - through - muchos a muchos django

¿Cómo trabajar con relaciones no salvadas de muchos a muchos en django?

Question

Tengo un par de modelos en django que están conectados de muchos a muchos. Quiero crear instancias de estos modelos en la memoria , presentarlos al usuario (a través de métodos personalizados -llamadas dentro de las plantillas de visualización) y, si el usuario está satisfecho, guardarlos en la base de datos.

Sin embargo, si trato de hacer algo en las instancias del modelo (métodos de representación de llamada, por ejemplo), aparece un mensaje de error que dice que primero tengo que guardar las instancias. La documentación dice que esto se debe a que los modelos están en una relación de muchos a muchos.

¿Cómo presento objetos al usuario y le permite guardarlos o descartarlos sin saturar mi base de datos?

(Creo que podría desactivar el manejo de transacciones y hacerlas yo mismo a lo largo de todo el proyecto, pero esto suena como una medida potencialmente propensa a errores ...)

¡Gracias!

Answer 1

Agregaría un campo que indica si los objetos son "borrador" o "en vivo". De esa manera se persisten a través de solicitudes, sesiones, etc. y django deja de quejarse.

A continuación, puede filtrar sus objetos para que solo muestren objetos "activos" en vistas públicas y solo muestren objetos "borrador" al usuario que los creó. Esto también se puede extender para permitir objetos "archivados" (o cualquier otro estado que tenga sentido).

Answer 2

Creo que el uso de formularios django puede ser la respuesta, como se describe en esta documentación (búsqueda de m2m ...).

Editado para agregar alguna explicación para otras personas que puedan tener el mismo problema:

di que tienes un modelo como este:

from django.db import models
from django.forms import ModelForm
class Foo(models.Model):
name = models.CharField(max_length = 30)
class Bar(models.Model):
foos = models.ManyToManyField(Foo)
def __unicode__(self):
return " ".join([x.name for x in foos])

entonces no puedes llamar a unicode () en un objeto Bar no guardado. Si desea imprimir cosas antes de que se guarden, debe hacer esto:

class BarForm(ModelForm):
class Meta:
model = Bar
def example():
f1 = Foo(name = ''sue'')
f1.save()
f2 = foo(name = ''wendy'')
f2.save()
bf = BarForm({''foos'' : [f1.id, f2.id]})
b = bf.save(commit = false)
# unfortunately, unicode(b) doesn''t work before it is saved properly,
# so we need to do it this way:
if(not bf.is_valid()):
print bf.errors
else:
for (key, value) in bf.cleaned_data.items():
print key + " => " + str(value)

Entonces, en este caso, debe haber guardado objetos Foo (que puede validar antes de guardarlos, usando su propio formulario), y antes de guardar los modelos con varias claves, también puede validarlas. Todo sin la necesidad de guardar datos demasiado pronto y estropear la base de datos o lidiar con transacciones ...

Answer 3

Respuesta muy tardía, pero el equipo de Wagtail ha hecho una extensión separada de Django llamada django-modelcluster . Es lo que impulsa los avances preliminares del borrador de su CMS.

Te permite hacer algo como esto (desde su LÉAME):

from modelcluster.models import ClusterableModel
from modelcluster.fields import ParentalKey
class Band(ClusterableModel):
name = models.CharField(max_length=255)
class BandMember(models.Model):
band = ParentalKey(''Band'', related_name=''members'')
name = models.CharField(max_length=255)

Entonces los modelos se pueden usar así:

beatles = Band(name=''The Beatles'')
beatles.members = [
BandMember(name=''John Lennon''),
BandMember(name=''Paul McCartney''),
]

Aquí, ParentalKey es el reemplazo de ForeignKey de Django. Del mismo modo, tienen ParentalManyToManyField para reemplazar ManyToManyField de Django.