Impostazione del proprietario dell'oggetto con vista generica create_object in django

Question

È possibile utilizzare la vista create_object per creare un nuovo oggetto e automaticamente assegnare request.user come chiave esterna?

P.E:

class Post(models.Model): 
    text = models.TextField() 
    author = models.ForeignKey(User) 

Quello che voglio è quello di utilizzare create_object e riempire autore con request.user.

Answer 1

In molti modi, tutte le soluzioni a questo saranno più problemi di quanto valgano. Questo si qualifica come un hack. È possibile che un aggiornamento di django ti lasci a bocca asciutta se cambiano il modo in cui viene implementato create_update. Per motivi di semplicità, supporrò che si stia tentando di impostare un utente predefinito, non forzare in modo silenzioso l'utente a essere l'utente che ha effettuato l'accesso.

Scrivi un processore contesto:

from django.views.generic.create_update import get_model_and_form_class 
def form_user_default(request): 
    if request.method == 'GET': 
     model, custom_form = get_model_and_form_class(Post,None) 
     custom_form.author = request.user 
     return {'form':custom_form} 
    else: return {} 

Che cosa questo farà è sovrascrivere l'oggetto della forma che create_update passa al modello. Ciò che sta facendo tecnicamente è ricreare il modulo dopo che è stato eseguito dalla visualizzazione predefinita.

Poi, nel tuo conf url:

url(r'pattern_to_match', 'django.views.generic.create_update.create_object', kwargs={'context_processors':form_user_default}) 

Ancora una volta, ho dovuto approfondire il codice sorgente per capire come fare questo. Potrebbe essere davvero meglio provare a scrivere la propria vista (ma incorporare il maggior numero possibile di oggetti personalizzati Django). Non esiste un modo "semplice predefinito" per farlo, perché nei paradigmi di Django i moduli sono più strettamente legati al livello del modello che alle viste e solo le viste hanno una conoscenza dell'oggetto richiesta.

Answer 2

Se un utente è autenticato, il suo oggetto utente è l'oggetto request.user.

Non ho familiarità con create_object ... Sono ancora un principiante del django e ho appena iniziato il mio primo vero progetto con esso.

Si noti che è necessario verificare che un utente abbia effettuato l'accesso prima di utilizzarlo. Questo può essere fatto con request.user.is_authenticated().

Answer 3

Non esiste un modo valido per agganciarsi al salvataggio di un oggetto quando si utilizzano le viste generiche Django correnti. Una volta che sono rewritten as classes, sarete in grado di sottoclasse la vista e di collegarvi al posto giusto senza dover riscrivere l'intera vista.

Uso già le mie viste generiche basate sulla classe per questo motivo.

Answer 4

vorrei suggerire di fare un wrapper per il create_object, come questo autore suggerisce http://www.b-list.org/weblog/2006/nov/16/django-tips-get-most-out-generic-views/ nella vista avrete accesso alle informazioni dell'utente. In seguito, sarà necessario utilizzare extra_context per passare l'utente al modello. Infine, nel modello è possibile aggiungere un campo nascosto con le informazioni dell'utente. Non l'ho provato, ma ci ho pensato per un po 'di tempo. Spero che questa soluzione sia adatta a te! ;) evviva!

Answer 5

Si consiglia di prendere in considerazione una chiusura.

from django.forms import ModelForm 
from django.views.generic.create_update import create_object, update_object 

def make_foo_form(request): 
    class FooForm(ModelForm): 
     class Meta: 
      model = Foo 
      fields = ['foo', 'bar'] 

     def save(self, commit=True): 
      f = super(FooForm, self).save(commit=False) 
      if not f.pk: f.user = request.user 
      if commit: f.save() 
      return f 

    return FooForm 

def create_foo(request): 
    FooForm = make_foo_form(request) 
    return create_object(form_class=FooForm) 

V'è una certa inefficienza qui, in quanto è necessario per creare l'oggetto ModelForm su ogni richiesta, ma permette di iniettare la funzionalità nella vista generico.

È necessario decidere se la complessità aggiunta per la creazione di form vale la pena di mantenere la semplicità dal lato della vista.

Un vantaggio qui, però, è che questo funziona anche con il caso di aggiornamento praticamente senza sforzo supplementare:

def update_foo(request, object_id): 
    FooForm = make_foo_form(request) 
    return update_object(form_class=FooForm, object_id=object_id) 

Ovviamente, è possibile utilizzare questo approccio per i casi più complessi, come bene.