formas de Django: forma más DRY para organizar crear formularios/actualización para los modelos heredados

Question

tengo 2 modelos de mesas múltiples hereditarias como éstas:

class Post(models.Model): 
    title = models.CharField(max_length=100, blank=True, null=True) 
    text = models.TextField(blank=True, null=True) 
    location = models.PointField() 
    ... 

class BlogPost(Post): 
    blog = models.ForeignKey(Blog) 

Del mismo modo, la clase de forma de BlogPost también hereda de la clase PostForm:

class PostForm(MapModelForm): 
    ... 
    class Meta: 
     model = Post 

    def clean(self): 
     ... 

class BlogPostForm(PostForm): 
    class Meta: 
     model = BlogPost 

Solía ​​manejar la creación/actualización para ambos modelos en 2 vistas no basadas en clase. Para hacer las cosas SECAS, decidí probar las vistas genéricas basadas en clases de Django. Pero debido a la falta de ejemplos y la hostilidad del usuario con los documentos relacionados y la variedad de enfoques, estoy confundido.

La idea es tener vistas de formulario basadas en clases para el modelo Post y heredarlas para el BlogPost. ¿Cómo debo adaptar las clases de vista?

¿Debo tener vistas separadas PostCreate y PostUpdate? Entonces las dos clases son casi idénticas y no SECAS en absoluto.

¿Debo tener un solo FormView para actualizar/crear una publicación? Funciona para la creación, pero no pude encontrar la manera de hacer esto para la actualización.

¿Debo crear una vista personalizada (o dos vistas para crear/actualizar) utilizando las clases de mixin proporcionadas en lugar de heredar las vistas directamente?

Answer 1

Tiene razón en que la documentación de vista basada en clase es bastante primitiva. Sin dudas mejorará, pero por el momento debe estar preparado para experimentar y para read the source.

usted está tratando de hacer dos cosas:

1. encontrar una buena manera de organizar sus puntos de vista el uso de clases.
2. Refacturar su código para evitar repeticiones.

Es importante abordar estos a la vez. Primero determine la jerarquía de clases correcta, y solo luego averigüe cómo factorizar la repetición.

Vamos a probarlo. Su jerarquía de clases va a ser algo como esto:

from django.views import generic 

class PostCreateView(generic.CreateView): 
    form_class = PostForm 
    model = Post 

class PostUpdateView(generic.UpdateView): 
    form_class = PostForm 
    model = Post 

class BlogPostCreateView(generic.CreateView): 
    form_class = BlogPostForm 
    model = BlogPost 

class BlogPostUpdateView(generic.UpdateView): 
    form_class = BlogPostForm 
    model = BlogPost 

Esto implica una gran cantidad de repetición, pero está claro ahora cómo factorizar a cabo algunas de ellas:

from django.views import generic 

class PostView(generic.FormView): 
    form_class = PostForm 
    model = Post 

class PostCreateView(PostView, generic.CreateView): pass 
class PostUpdateView(PostView, generic.UpdateView): pass 

class BlogPostView(PostView): 
    form_class = BlogPostForm 
    model = BlogPost 

class BlogPostCreateView(BlogPostView, generic.CreateView): pass 
class BlogPostUpdateView(BlogPostView, generic.UpdateView): pass 

Y si todavía descontento con la cantidad de repetición aquí, puede automatizar aún más la construcción de estas clases (usando type para crear clases en tiempo de ejecución). Sin embargo, eso es probablemente un paso demasiado lejos, hasta que esté completamente cómodo con el uso de vistas basadas en clases.