Ciao e benvenuto a un altro Django
per tutti a piedi attraverso.
Quindi probabilmente sei a questo punto a
lavorare sul tuo incarico di auto.
Questo è il nostro primo vero
compito di creare, leggere, aggiornare ed eliminare.
Molto di ciò che questo compito è,
è quello di guardare il codice che
ti ho dato in DJ4E Samples e tirarlo dentro.
Non clonare il repository per questa assegnazione.
I campioni DJ4E sono un mostro.
Ha tutti i tipi di cose in
esso, è troppo complesso e non vuoi.
Vuoi iniziare con un'applicazione bella e pulita.
Il tuo precedente incarico era quello di fare
una minuscola applicazione,
estenderemo quell'applicazione.
Ecco perché hai già
questi progetti DJ4E nel tuo ovunque si trovi.
Quindi, di cosa si
tratta, questo compito è
quello di evolvere usando il codice di esempio.
Ma quello che sto davvero per
fare è che ho intenzione di camminare attraverso
il codice di esempio perché ci sono
nuovi concetti in questo codice di esempio.
Quindi questa è più una lezione
sul codice di esempio che esattamente come fare l'incarico.
Ma soprattutto, è necessario
capire ogni singola riga perché letteralmente,
ogni programma che scriveremo per
le prossime n settimane è una variazione su questo CRUD.
Quindi queste visualizzazioni predefinite,
il get 404,
tutte quelle cose sono davvero una base in molte cose.
Quello che troveremo è il
modo giusto per scrivere questo codice,
come tutto in Django,
è davvero piccolo e succinto.
Quindi diamo un'occhiata al codice.
Bene, andiamo avanti ed eseguiamo il codice.
Vai alle auto, e devi effettuare il login.
Quindi l'idea di questo è che ci sono due tabelle.
C' è una tabella di marche.
Quindi ho intenzione di aggiungere un make
e poi ho intenzione di aggiungere un'auto,
e la cosa interessante di questo è questo Neon
1, chilometraggio 1,234, SakalCard.
Quindi ho questo fantastico menu a discesa.
Quindi c'è un sacco di moduli in corso qui,
ci sono a discesa, c'è una
relazione da molti a uno in corso.
Quindi ho questa lista e posso aggiornarla ed eliminarla.
Ecco dove si trova il nostro CRUD completo.
Così possiamo aggiungere marche,
visualizzazione rende, aggiungere auto, ecc
Quindi questo è tutto il campione.
Quindi è molto vicino a quello che devi scrivere,
è solo che non andare a prendere e tutta quella roba.
Quindi iniziamo dando un'occhiata.
Quindi sono qui seduto nei miei campioni DJ4E.
Se guardi, vedi tutte le
mie varie applicazioni sotto un progetto.
Quindi abbiamo le auto,
ma voglio davvero iniziare con il codice di autenticazione,
se torno qui ai campioni,
lasciami uscire, il codice che mi permette di accedere.
Quindi se vado direttamente alle auto per vedere se ho effettuato il logout.
Noterai che quello che fa
quando vado direttamente alle auto,
è che mi instrada per accedere,
e poi con il prossimo per tornare all'auto.
Quindi questa vista in autos,
il/autos si è protetta con il mixaggio di login.
Più tardi faremo il login,
il tuo login non sarà del tutto simile a
questo, ma questo è quello che ho sui campioni.
Non devi ancora renderlo carino,
un prossimo incarico che renderà tutto bello.
Quindi ora siamo in auto e abbiamo effettuato l'accesso.
La tua applicazione deve avere altre cose qui,
ma sono più interessato a
mostrarti davvero l'essenza dei punti di
vista in queste auto.
Esaminiamo brevemente come funziona l'accesso automatico.
Quindi, se guardo dj4e-samples/settings.py,
è necessario avere questa autenticazione collegata.
Quindi fondamentalmente è un mucchio di codice, alcune visualizzazioni,
ecc., Che proviene da Django,
e che è stato lì per tutto il tempo
quando hai fatto il tuo progetto iniziale.
Ovviamente, da qualche parte qui dentro,
dobbiamo avere le auto, ovunque si trovino le auto.
Sì, configurazione dell'app autos,
devi inserire l'app autos.
Se do un'occhiata a dj4e-samples/urls.py,
allora posso trovare le auto qui,
e ci deve essere una riga che dice fondamentalmente,
«Al livello superiore,
tutto sotto le auto è delegato
al file URL in autos.py.
Ma anche allora ci sono i conti.»
Quindi, se ricordi,
questo è un mucchio di punti di vista che provengono da Django per noi,
è preinstallato per noi.
La cosa che dobbiamo fare è che dobbiamo
fornire questo un modello
con il nome registration.html.
Quindi penso di averlo a casa/modelli/registrazione/.
Sì, lo so. Quindi in realtà ho due accessi.
Ne ho uno davvero semplice come login.html.
Questo è quello che consiglio di iniziare con.
Più tardi useremo il social login. Questo è molto semplice.
È una pagina di accesso che utilizza la capacità di moduli di Django.
Se si formano errori,
ciò significa che c'è un errore di convalida.
È tornato indietro e ha mostrato di nuovo
questa pagina e ti ha mostrato un errore.
Quindi facciamo un semplice modulo di post con un URL
che è una ricerca inversa di una vista con un nome di login.
Poi inseriamo il token CSRF e poi prendiamo la forma,
e sto solo facendo questo con i tag di paragrafo.
Quindi questo è un semplice login,
non è quello reale che stiamo mostrando.
Quindi il prossimo è un valore nascosto che devi passare
in modo che quando esegui effettivamente il login con successo,
sappia tornare alle auto.
Quando è tutto finito, torna
qui dopo che il login è stato fatto.
In modo che la registrazione/login,
puoi metterlo in una qualsiasi delle tue applicazioni,
ma vuoi chiamarlo registration/login.html.
Quindi, se do un'occhiata molto veloce
e vado in casa/modelli,
questi sono tutti i modelli.
Quando faccio un ls, vedrai che ho
una casa/modelli/casa e una casa/modelli/registrazione.
Puoi avere più di una cartella qui.
Se guardo cosa c'è in registrazione,
vedi che ho questo semplice login e poi
il login più complesso che ci darà
le funzionalità di login di GitHub.
Quindi ciò significa che il login usa social.
Il punto è sotto questi modelli,
non è necessario avere solo una sottocartella,
è possibile avere più di una sottocartella.
Quindi questa è la configurazione necessaria per farlo in modo
che quando diciamo alle nostre opinioni di aggiungere il mixin di login,
che vedremo in un secondo.
Diciamo alle nostre opinioni nel login di utilizzare il mixin di login,
quindi sa da dove ottenere il modello.
Quindi questo è solo una parte e
le tue istruzioni ti dicono come farlo.
Quindi qualsiasi applicazione che stai per
costruire o qualsiasi progetto che stai per costruire,
devi inserirli in impostazioni py,
urls.py, e quindi creare il modello.
Quindi devi iniziare a usare
login mixin e poi tutto
inizia magicamente a venire insieme.
Quindi diamo un'occhiata all'applicazione effettiva auto.
Vedremo un paio di cose diverse
qui, auto/URL.
Ho intenzione di fare una scheda multi-terminale,
quindi posso tornare da un file all'altro molto velocemente.
Probabilmente hai un editor di testo migliore di me.
Quindi ho gli URL,
ho intenzione di dare un'occhiata a autos/views.py.
Poi ho intenzione di guardare autos/model.py.
Poi ho intenzione di guardare autos/forms.py.
Quindi cerchiamo di lavorare attraverso questi quattro file,
URL, viste, modelli, moduli.
Probabilmente facciamo i modelli prima.
Quindi questo è abbastanza semplice.
Stiamo andando a fare una classe oggetto Make.
Avrà un campo di caratteri
con alcuni validatori al suo interno.
Giochiamo con quello con le forme.
Puoi inserire i validatori nei modelli.
In precedenza abbiamo visto i validatori in forma,
ma c'è un validatore che fondamentalmente dice,
non accetteremo i dati che entrano in
questa tabella di database a meno che non
ci siano almeno due caratteri.
Questo _str_, lo stai facendo per un po'.
Questo fondamentalmente è se prendi
un oggetto modello una marca effettiva e lo stampi,
dice quale dei campi,
in questo caso, c'è solo un campo.
Quindi questo dice solo quando stiamo convertendo
un oggetto modello in una stringa,
possiamo decidere come appare.
Poi abbiamo un'automobile e ha
un soprannome con un minLengthValidator, max_length di 200,
e chilometraggio, che ha un campo intero, un commento,
che è un campo di 300 caratteri,
e poi anche una chiave esterna.
Questo come una relazione uno-a-molti o molti-a-uno,
non un molti-a-molti, solo una chiave esterna in to Make.
Poi andremo a on_delete
CASCADE che significa davvero che se si elimina un Make,
allora le corrispondenti voci automatiche
verranno automaticamente cancellate.
Quindi questo è un modello piuttosto semplice,
in realtà molto, molto semplice.
Ancora una volta, definiamo sempre
questo _str_ (self) in modo da sapere che se
lo stai mostrando come nell'
interfaccia di amministrazione o se
lo stai semplicemente stampando o semplicemente
convertendo il modello stesso in una stringa,
il campo tra questi campi che
dovrebbe essere usato è il ,
solo per mostrare agli utenti finali.
Quindi questo è il file dei modelli.
Diamo un'occhiata al file di moduli successivo.
Quindi il file del modulo è interessante,
perché abbiamo visto moduli che
sono solo moduli da soli,
ma questo è un tipo speciale di
forma e quindi è un ModelForm.
In questo, normalmente negli altri modelli,
avevamo tutti questi campi,
e li abbiamo inseriti e sembrava
molto simile a un file modello in cui
abbiamo un campo di caratteri, PositiveIntegerField.
Ma quello che stiamo praticamente dicendo e', sai una cosa?
Faremo un modulo qui.
In realtà, tutto ciò che vogliamo fare è prendere
tutti i campi
dal modello Make e renderli campi modulo.
Quindi una forma e un modello sono due cose diverse.
Un modulo è qualcosa che va
tra la vista e il modello,
e come vedrai,
va anche giù nei modelli automaticamente,
quindi questo è proprio come rendere tutti i campi.
Creiamo un modulo perché
gli oggetti modulo non devono essere associati ai modelli.
Ma in questo caso, stiamo andando a
derivare un oggetto modulo da un modello.
Quindi, invece di estendere la forma, stiamo estendendo ModelForm.
Quindi questo è un ModelForm deve avere,
e questo è solo alcuni dati che dicono che il modello che
stiamo per tirare tutti i nostri campi da è il modello Make,
e ha solo una cosa che è un nome.
Questo è tutto. Quindi questo sta generando automaticamente
un modulo che se
lo cambiassimo e aggiungiamo un altro campo qui,
allora questo modulo make avrebbe automaticamente un campo.
Puoi dargli un elenco di campi,
_ _ _ tutti _ _ _ è
come un segnale per dire, «Dammi tutti».
Ora potrebbero esserci alcune
cose interne come create e
aggiornate o qualcosa che non si desidera utilizzare.
Quindi questa è una forma, ricorda come funzionano le forme.
Lo copriamo prima. Diamo un'occhiata ai nostri URL.
Ora un sacco di questo sembra
abbastanza simile a quello che abbiamo fatto.
Abbiamo fondamentalmente una tabella principale,
che è la nostra tabella di auto,
e la nostra tabella di ricerca, che è la nostra tabella di marche.
Poi abbiamo tre cose,
c'è la vista elenco principale,
che è elencare tutte le auto.
C' è la principale visualizzazione elenco Make,
che è elencare tutte le marche.
Quindi possiamo crearne
una nuova che non ha una chiave primaria,
perché parte delle idee che
creano sta creando una cosa nuova,
che sta per generare una chiave primaria.
Poi avremo un aggiornamento e una cancellazione.
Quindi abbiamo una lettura, creare, aggiornare, eliminare.
Quindi non è esattamente cred,
ma vedete tutte e quattro queste cose.
Quindi abbiamo viste,
e chiamiamo queste viste in modo da
poterle fare riferimento nei nostri punti di vista
stessi e nel nostro modello
in modo da poter creare collegamenti tra di loro.
Quindi questi sono piuttosto
semplici e non così diversi.
Quindi il divertimento inizia ad accadere quando siamo nel views.py.
Quindi login mixin,
se ricordi dall'autore di z walk-through,
basta aggiungere questo a una vista e
fondamentalmente dice che non puoi arrivare
a questa vista a meno che tu non abbia effettuato l'accesso
e se non hai effettuato l'accesso,
si verificherà nel
file login.html e poi rimbalzerà dopo che sei stato fatto.
Quindi LoginRequiredMixIn è tutto ciò che dobbiamo fare.
Se vai al campione z autore,
vedrai come l'ho fatto a mano.
Se non vuoi farlo a mano,
basta chiamare login mixin.
Ora, quindi questa vista principale è una vista elenco,
e quindi andiamo
a dare un'occhiata a come questo sarà simile.
Questa è la visualizzazione Elenco.
Quindi stiamo andando a prendere tutti i controlli che abbiamo,
stiamo andando a scorrere attraverso quella lista,
stiamo andando a recuperare tutti gli audit dal database.
Poi avremo un add il link automatico,
quindi una vista che crea il link con
un conteggio di quante marche ci sono e aggiungere un make.
Quindi lasciami anche andare in modelli di auto, auto
di nuovo e lista automatica.
Quindi questo è il modello che lo rende.
Quindi ci sono un paio di cose che otteniamo,
otteniamo una lista di auto.
Ora i nomi di questi non ti sono obbligati,
ma ci sono convenzioni che si rivelano tra un attimo,
sembreremo davvero utili.
Quindi avremo una lista di auto.
Se torniamo nei nostri punti
di vista, vediamo che diciamo, ottenere tutti gli oggetti dalla tabella automatica,
tutti gli oggetti classe auto recuperano tutti,
passandoli nel contesto come auto_list.
Ora vogliamo anche essere in grado di
mostrare quel piccolo conteggio, questo è il numero due,
quindi stiamo andando a chiedere,
andare avanti al fare
tutti gli oggetti, ma non darmi una lista di loro,
contarli e darmi un numero.
Quindi fai il conteggio è bloccato lì e
vedrai se il conteggio può essere maggiore di zero.
Possiamo mostrare l'annuncio e il pulsante automatico,
e anche da qualche parte mostra il conteggio make,
visualizzare tutte le marche, aggiungere un make,
e il make count viene fuori qui.
Quindi e' un'altra cosa che mettiamo.
L' elenco automatico che stiamo per passare attraverso e quella
variabile di iterazione di auto sta andando a
passare attraverso ciascuna delle cose separate,
e nickname, make, ecc,
Questo è direttamente fuori dal file models.py.
Ci sono le quattro cose che ogni auto ha,
e stiamo solo stampando tutta questa roba.
Si ottiene anche la chiave primaria,
e quindi stiamo andando a fare un URL di aggiornamento,
e che URL è di autos: auto_update.
Quindi, se si guarda in urls.py,
vediamo questo aggiornamento automatico cerca in alto,
questo ci dà un percorso alla vista,
ma quel particolare percorso ha bisogno di un
parametro che è una chiave primaria,
e quindi ciò significa che questo tag modello URL,
autos deve avere l'auto.id
Ma perché stiamo eseguendo il ciclo attraverso i modelli,
ne hai uno, e fai un
auto_create, è piuttosto semplice.
Ma una delle regole è, devi avere
almeno una marca prima di poter fare un'auto,
perché se ricordi,
aggiungi un'auto deve avere
questo elenco a discesa popolabile e
che viene estratto dalla tabella make,
e quindi questo è fondamentalmente il modo in cui aggirare questo.
Questa è la vista principale.
Eccoci, aggiorna.
Questa è la vista delle auto, e poi se facciamo il make view,
stiamo facendo la stessa cosa.
Se andiamo a guardare la lista di marca,
stiamo facendo la stessa cosa di base, vediamo
tutte le marche,
e ora abbiamo aggiornamento ed eliminazione.
In questo modo non hai bisogno di contare.
Vogliamo solo afferrare tutti gli oggetti,
vogliamo metterlo in un contesto sotto make list,
e poi facciamo lista sul HTML,
e questo è ancora più semplice.
Sta solo passando attraverso la lista di marca,
entra nel contesto.
Se non ce n'è, non stampiamo questo,
e poi mettiamo fuori il nome di esso,
e poi abbiamo un aggiornamento e un pulsante di eliminazione
che va all'aggiornamento e all'eliminazione,
e, naturalmente, se si guarda in urls.py,
quelli anche l'aggiornamento e l'eliminazione
hanno requisiti di chiave primaria,
e così hai una chiave primaria
che devi passare qui per
rendere quell'URL l'URL corretto,
e quindi solo alcuni link per
tornare alle varie cose in modo che
possiamo tornare alle auto,
visualizzare rende, aggiungere una nuova marca.
Ora, cancella tutta quella roba.
Quindi questo è il views.py
per elencare le auto e le marche.
Ora, vogliamo rendere il make create vista.
Quindi, se diamo un'occhiata al make create view,
cioè aggiungere un make.
Questo creerà questo modulo.
Posso ingrandirla qui.
Può creare questo modulo,
dove metteremo una cosa chiamata Chevy.
Quindi abbiamo bisogno di un modo per creare questo modulo.
Faremo un login richiesto,
non lasceremo che la gente lo faccia.
Avremo alcune variabili che sono di classe,
come quale modello vogliamo usare,
e success_url è dopo che abbiamo fatto questo bene.
Ora, se
lo invii e si lamenta, non lo fa.
Ma una volta fatto bene,
dove vuoi andare dopo?
Allora, Chevy, dove vuoi andare dopo?
Questa è la funzione controller.
Voglio tornare alla lista automatica,
e quindi il success_url è
andare su auto: tutto ciò che in urls.py è questa vista principale.
Questo è il nome della vista principale,
e quindi se andiamo qui,
quale modello utilizzare e quale success_url.
Se facciamo una richiesta get,
stiamo andando a costruire un modulo per
il make che proviene da make form,
ma in realtà proviene dal modello make,
che è solo un campo stringa.
Semplice come questo. Lo stiamo riutilizzando.
Stiamo solo dicendo, facciamo un modulo
che tira fuori da qui.
Dobbiamo passare un modulo in,
perché i modelli non possono essere utilizzati per creare questa schermata.
Quella schermata viene da un modulo.
Ok. Se diamo un'occhiata al modello,
se guardiamo al make creare
modello o fare modulo.
Quindi questo è il modello che useremo per creare forma.
Avremo bisogno di form_as_table.
Quindi è da come abbiamo fatto le forme.
Metti il token CSRF,
fai una tabella,
che potrebbe essere come paragrafi o come tabelle.
Ma qualunque cosa, hai bisogno di questo oggetto modulo.
Quindi è necessario passare l'oggetto modulo in.
Quindi eccoci qui, stiamo andando a fare un modulo
e poi stiamo andando all'oggetto modulo in,
e poi stiamo andando a rendere a self.template
autos.makeform html.
Allora lo restituiremo per il get.
Poi quando abbiamo premuto il pulsante
il pulsante di invio, Aggiungi un make,
abbiamo premuto il pulsante di invio,
sta entrando nel post
perché abbiamo fatto un post modulo, entra in.
Non farlo. Questo è terribile.
Odio quando vi fa così.
Ma eccoci qui, siamo tornati.
Sì. Quindi il post entra,
request.post ha tutte le coppie di valori chiave
che sono queste coppie chiave-valore come definito dal modulo.
Quindi diciamo facciamo un modulo make con
i dati iniziali provenienti dal post di richiesta.
Dato che il modulo lo ha generato,
sa quali sono i nomi di questi campi,
e questo è qualcosa che si nasconde dietro come funzionano i moduli.
Ma controlla anche se i dati del modulo sono validi e
ciò significa che siamo tutte queste regole di validatore seguite.
Se le regole del validatore non vengono seguite,
se il modulo non è valido,
lo rimanderemo indietro.
Quindi questo codice qui,
questo modulo non è un codice valido.
Se inserisco una singola lettera A e premo «Invia»,
tornerà e restituirà nuovamente
il modulo e tutte quelle cose degli errori,
tutta quella roba è gestita da questo codice di modulo,
questo codice di modulo Django capisce cosa c'è che non va.
Proprio un po', cosi' posso
tornare piu' velocemente. Ci siamo.
Capisce cosa c'è di sbagliato,
fa un messaggio di errore,
il messaggio di errore proviene da models.py proprio qui.
No, proprio qui.
Poi è passato attraverso forms.py perché è
una forma alla fine che abbiamo ereditato dalla
forma del modello. Capirlo?
Quindi e' figo. Quindi questa è la condizione di errore,
e altrimenti facciamo forma.save.
Ora la cosa qui che è davvero super
cool è perché questo modulo è
un modulo modello e
i nomi dei campi sono
gli stessi dei nomi dei campi nel modello,
e quindi in realtà fa un salvataggio sul modello stesso.
Quindi in un modo il modulo contiene i dati del modello
che provengono dalla richiesta di post e quindi lo salva. In
questo modo viene salvato il modulo.
Lo mette in, e poi abbiamo appena
reindirizzato di nuovo all'URL della richiesta.
Questo mi è abbastanza succinta.
Estraiamo i vecchi dati del post,
controlliamo se è cattivo, se è cattivo,
inviamo il modulo allo
stesso identico modello che abbiamo
fatto e poi lo salviamo se è buono,
e poi salviamo all'URL di successo.
E' una cosa bellissima.
Ma proprio come in Django tutto il tempo,
questa è una cosa molto più comune da
fare anche se questa è super succinta.
Se lo facessi in quasi tutte le altre lingue,
saresti come 75 righe di codice,
e qui abbiamo come 15 righe di codice.
Ma si scopre che in Django c'è
quasi sempre un modo più conciso per farlo.
Abbiamo una vista generica di creazione.
Puoi dare un'occhiata alla documentazione per
questa vista generica di creazione, django.views.generic.edit.
Andiamo a cercare su Google questa roba.
Ho sempre messo un punto qui e questo di solito
mi fa bene perché
questo è il pacchetto reale e la classe all'interno
del pacchetto. Oh, no.
Mi dispiace. Pensavi che fosse un nome di dominio,
quindi la ricerca non ha funzionato.
Ma ora dirò solo Django,
qualcosa di così almeno
ha intenzione di fare con una ricerca per me, le
viste di modifica generiche saltano a CreateView.
Quindi puoi leggere tutte queste cose,
createView generico in realtà.
Ho un riferimento a questo?
Allora, eccoti qui. Dai un'occhiata a questo.
Ora, questo proprio come
alcune delle altre viste che abbiamo ereditato,
ha un sacco di funzionalità in esse.
Quindi, se voglio fare un AutoCreate,
questo è tutto ciò che serve.
Ora, AutoCreate e MakeCreate a
tutti gli effetti,
fate la stessa cosa.
Quindi, cosa succede in
AutoCreate perché stiamo estendendo CreateView
,
abbiamo tre bit di metadati, diciamo quale modello vogliamo usare,
quali campi da quel modello vogliamo
e dove l'URL di successo andare è.
Quindi questo genera tutto questo codice.
Abbiamo ereditato tutto quel codice.
Noterai che non c'è nulla di hardcoded
qui tranne il MakeForm.
Ora, non dobbiamo nemmeno creare un modulo per l'Auto
perché questo codice qui costruisce il modulo.
Non solo, ma utilizza questo nome
Auto per scegliere il modello.
Quindi se faccio auto_form,
devo usare questo.
Io uso questo, questo è il mio bootstrap di base.
Non preoccuparti troppo.
Quindi conosce il nome
del modello che utilizzerà.
Devo solo dirgli quale modello usare qui,
perché deriva il modello,
auto_form.html è il modello.
Abbastanza figo. Abbastanza fantastico e figo.
Quindi trova automaticamente quello e il success_url.
Quindi questo è tutto ciò che serve.
In effetti, in questo MakeCreate,
avrei potuto cancellare tutto questo codice da qui a qui,
ma invece basta fare un CreateView estendendo CreateView.
Quindi te lo sto mostrando solo perche' voglio che tu
veda cosa sta succedendo davvero.
Ma non è così che scrivi il tuo codice.
Ecco come scrivi il tuo codice.
Quindi ora, voglio mostrarti
il modo difficile di fare un aggiornamento.
Quindi cos'è un aggiornamento? Diamo un'occhiata al codice.
Quindi diamo un'occhiata a vista rende.
Aggiornamento è la cosa che
succede quando andiamo qui e
che sta per andare a MakeUpdate.
Quindi ecco MakeUpdate, ecco urls.py. E' questa.
Voglio dire, cerca l'aggiornamento della chiave primaria,
che poi se guardi qui sotto,
sarà autos cerca un aggiornamento.
Quindi aggiornero' quella Chevy.
Deve leggere i vecchi dati,
deve mostrarli a voi,
e poi lasciarci aggiornare e poi inviarlo controllando,
naturalmente, per eventuali errori di convalida.
Quindi reindirizzandoci di nuovo a un success_url.
Quindi, se guardiamo i punti di vista,
stiamo andando di nuovo,
prefigurando, c'è un modo molto più semplice per farlo.
Quindi impostiamo queste variabili o il success_url,
quale modello vogliamo, e il modello.
Poi abbiamo una richiesta get.
Perché nel urls.py c'è questo int:pk,
sono stati passati in questo valore pk.
Ora, questo get_object_or_404 è davvero fantastico.
Questo get_object_or_404 (self.model pk=pk).
Questo è questo parametro che stiamo passando
pk uguale ed è comune che siano lo stesso nome,
ma questo è un parametro per get_object_or_404.
Questo secondo è il parametro
che è stato chiamato al nostro get.
sé.Modello, naturalmente, è fare.
get_object_or_404 fondamentalmente controlla per vedere se
, farò questo aggiornamento,
andiamo a make, facciamo un aggiornamento.
Quello che sta facendo è prendere questo numero,
questo tre qui, auto/lookup/3/update,
e sta recuperando i vecchi dati.
Ora, cosa succede se ho
inavvertitamente un numero
che non esiste nel database,
come 9.999, e faccio una richiesta get a quello?
Ottengo «Pagina non trovata 404».
Quindi quello che sta succedendo qui è in qualche modo dici, «Ehi,
carica questo oggetto e dammelo a me e alla variabile
, fai, o semplicemente esplodi e invia un errore 404.»
Quindi questo ti sta dicendo cosa sta succedendo,
quale vista ti basta, «No Make corrisponde alla query data.»
Ora, generalmente non si dovrebbe digitare a mano questi.
Tre funziona, e quindi non esplode.
Quindi get_object_or_404 è un modo per caricare
i vecchi dati e quindi
proteggere usando quei dati, o semplicemente saltare in aria.
Quindi non andare oltre a quel punto.
Ora, allora faremo
un modulo e lo riempiremo con i vecchi dati.
Quindi esempio, ciò che l'istanza è fare.
Quindi questo è l'oggetto.
Crea un MakeForm. Ecco un MakeForm.
Tutti i campi del modello
ereditano dal modello Make.
Quindi passalo al modello make_form.html,
che abbiamo appena guardato.
Questo modulo arriva, è tutto quello che ci serve.
Questo è molto generico.
Non gli importa molto.
È tutto praticamente codificato in questa forma,
che è derivato dal modello.
Poi, naturalmente, digitiamo un sacco di roba
e premiamo «Invia».
Fa esattamente la stessa cosa del Create,
e che fa bene.
In primo luogo deve fare un get o 404 perché
postiamo alla cosa con la chiave primaria.
Lo caricamo per assicurarci di avere un oggetto da aggiornare.
Quindi creiamo un nuovo modulo make
da quel database e poi cambiarlo.
Quindi questo è come i dati iniziali,
ma poi lo altera ai dati.
Quindi, in questo caso particolare,
Chevrolet è il vecchio valore nel database.
Se dico Bowtie,
richiedere post laboratorio Bowtie,
questo inizierà una Chevrolet ma in questo
oggetto modulo allora sarà Bowtie.
Naturalmente, se non è valido,
restituiremo un messaggio di errore proprio qui.
Se è valido,
lo salveremo e quindi questo nuovo Bowtie
verrà salvato lì dentro.
Quindi, se vediamo le nostre marche,
vediamo che ora è Bowtie,
e stiamo andando a reindirizzare a URL di successo.
Ora, a questo punto,
spero che tu possa prevedere
cosa succederà dopo.
AutoUpdate, estende la vista di aggiornamento,
la vista di modifica generica.
Dice quale modello è,
quali campi vuoi e
dove andare quando ha successo.
Allora fa tutto quello che c'e' qui dentro.
Letteralmente, potrei andare a dire
esattamente le stesse parole per make delete,
che è quello che succede quando si va qui
e si elimina e poi si dispone di un annullamento,
c'è una conferma cancellazione.
Il nome di questo modello non viene scelto
casualmente, deve essere chiamato il confirm.delete,
il modello confirm.delete.
Ecco a te. Devi fare il token CSRF.
Ti viene consegnata la marca come oggetto in questo.
Quindi questo produce questo output.
Non c'e' nessuna forma in questo.
C' è solo la marca che viene caricata dall'
oggetto o 404 e poi passa make in e lo rende.
Poi, quando il post accade, lo recupera.
Se è lì, un 404
controlla nuovamente la presenza di dati errati ed eliminarli,
e quindi salta all'URL di successo.
Non ci vuole molto per indovinare cosa farò dopo,
e cioè, se estendi la vista di eliminazione,
ottieni tutto quel codice gratuitamente.
Basta dire quali campi modello
e dove andare per il successo.
Quindi la cosa chiave è che,
mentre fate i compiti,
sono sicuro che alcuni di voi copieranno e
incolleranno tutta questa roba. Questo è sbagliato.
MakeCreate, MakeUpdate e
MakeDelete devono essere brevi
come AutoCreate, AutoUpdate e AutoDelete.
Perché farai
molto queste visualizzazioni di modifica generiche e
faremo CRUD più e più volte,
e davvero non vuoi scrivere 15 righe di codice.
Questa è una ripetizione inutile, taglio,
incolla e modifica del codice non necessari se
riesci a mantenerlo davvero semplice.
Quindi posso fondamentalmente costruire un set completo di
moduli CRUD e funzionalità CRUD con
convalida per un modello con
questo codice e quindi non ho nemmeno bisogno di avere un forms.py,
ho solo un models.py.
Quindi, se stai facendo le tue auto,
penseresti che ho fatto
un errore se sto facendo un forms.py.
Perché se uso questo views.py in questo modo,
invece di farli sembrare tutti come MakeUpdate,
allora ti risparmierai un sacco di
tempo ed energia e dobbiamo modificare queste cose.
È molto più facile trovare
tutte le modifiche e quindi modificarle.
Quindi questo è un passaggio del codice di esempio per Autos.
Farai un incarico su questo,
ma non copiare tutto.
Ho impostato questo in modo che il
tempo passi a capire cosa sta succedendo,
in particolare nei punti di vista.
L' URL è il tuo orgoglio,
basta copiare,
i modelli che copi, gli URL che copi,
ma le viste non solo lo copiano,
capiscono cosa sta realmente succedendo e
escogitano il modo più semplice e conciso per fare tutte queste cose.
Django sta iniziando a sembrare
davvero bella a questo punto.
Quindi spero che tu abbia trovato questo utile. Salute.