Bene, tornate in questo video per mostrarvi come possiamo creare un'associazione da uno
a molti tra due modelli di mangusta incorporando dati e lavoreremo con utenti e post.
Quindi questo sarà come un'app di Facebook o di blog in cui abbiamo un utente e un utente può
avere molti post ma un post appartiene a un utente e non creeremo un'app effettiva qui con percorsi e modelli.
Ci concentreremo solo sui dati e sulla modellazione dei dati.
Quindi ho intenzione di iniziare creando un nuovo file all'interno di questa directory delle associazioni che ho creato.
Puoi farlo ovunque tu voglia.
Sarà un singolo file e lo chiamerò embed punto J. S. mangusta e ci vorrà un momento.
e aprirò questo e dentro di qui richiederò mangusta che non ho ancora installato quindi lo farò dopo e
installerò la
Eccoci.
Facciamo un po 'di spazio.
E una volta che lo richiediamo, la prossima cosa che vogliamo fare è connettersi a un database in modo che
la mangusta si connetta e questo è totalmente da noi il nome del database, ma deve essere Mangu DB
due barre barra barra locale barra e chiamata .
Questa demo del blog è proprio così e salva.
OK, quindi ora abbiamo bisogno di definire due modelli che abbiamo utente e abbiamo un post.
L'utente avrà solo un'e-mail e un nome e un post.
Avrà un titolo e poi un contenuto.
Il vero post stesso.
Quindi inizieremo con la necessità dell'utente di definire lo schema.
Finora lo schema utente è uguale al nuovo schema di mangusta e quindi avremo e-mail che è una stringa e un nome
che è una stringa proprio così.
E poi creeremo il modello finora.
L'utente è uguale a utente del modello mangusta.
La versione Cingular e quindi lo schema utente sono ciò da cui stiamo costruendo.
E lo salveremo.
OK.
Ora passiamo al post.
Quindi stavamo per creare un altro schema questa volta var post schema equivale a nuovo schema di mangusta e quindi ogni post ha
un titolo che è una stringa e contenuto che creerà anche una stringa.
trasformarlo in un modello di modello var post uguale al modello di fermata mangusta dopo schema di virgola.
E poi abbiamo anche bisogno di
Destra.
Quindi abbiamo due schemi per impostare due modelli.
Facciamo un pò di spazio qui.
Quindi abbiamo i nostri post e abbiamo i nostri utenti.
E proviamo a farlo.
Assicurati di non avere errori di sintassi per avviare il nodo Embedded Dutcher Sì.
Sembra buono.
Ora andiamo a creare un singolo utente solo per assicurarci che il nostro modello funzioni.
Quindi in fondo ho fatto un nuovo utente, quindi chiameremo il
nostro nuovo utente come nuovo utente e poi passeremo un'email e l'email sarà Charlie in giro per Edu e il nome sarà Charlie
Brown proprio così.
E poi cosa salva un nuovo utente da salvare.
E poi aggiungeremo la nostra callback con l'errore e poi i dati che ritornano, che si
spera siano i nostri utenti e poi non solo voi.
Se l'errore annulla l'errore di registro.
Altrimenti cancelleremo quell'utente del registro.
Quindi finora nessuna associazione.
Sto solo testando per vedere se il nostro modello utente funziona.
Quindi, eseguiamo questo nodo embed Dutchesse e otteniamo il nostro utente indietro con l'ID che è stato generato
automaticamente nome ed email.
Fantastico, proviamo la stessa cosa con la posta quindi commentala così non otteniamo
un altro utente e faremo il nostro nuovo post equivale a un nuovo post e un post ha un titolo e il titolo del post sarà
riflessioni sulle mele e il testo di quel post o il contenuto.
Penso che lo abbiamo chiamato sì, il contenuto sarà.
Sono deliziosi.
Tutto ok.
Ottimo post sul blog lì.
Salveremo per accertarci che tutto sia in ordine e quindi faremo effettivamente un nuovo post che salva
di nuovo noi e il callback.
Si spera che tu ti senta a tuo agio con questo modello perché lo stai vedendo ininterrottamente
dove passano questa richiamata alla mangusta.
Ogni volta che facciamo qualsiasi cosa con Monga è trovare la possibilità di creare un aggiornamento di salvataggio, eventualmente rimuovendo
alla fine la necessità di passare un callback con l'errore come primo parametro e poi i dati
come secondo.
Tutto ok.
Quindi, se l'errore annulla il log, altrimenti verrai su quel post del blog assicurati che entrambi funzionino.
Proviamo e ci imbattiamo in un piccolo problema.
Ci sta dicendo che il post non è definito quando stiamo cercando di creare un nuovo post.
E la ragione più logica per cui ciò accada sarebbe se abbiamo nominato il nostro modello qualcosa di diverso dal post.
E tu cosa sai
L'abbiamo chiamato post model e per intenderci l'ho chiamato erroneamente.
Quindi andiamo con il post.
Potremmo averlo mantenuto come modello di post e poi cambiato qui.
Ma è decisamente convenzionale avere solo il nome di quello che stai facendo non
è necessario avere un modello lì dentro non hai bisogno di caratteri extra solo il nome del
modello stesso o del post dell'entità con una maiuscola P. Va bene così che partite ora.
Bene, abbiamo post e post qui.
Proviamo di nuovo e questa volta aggiunge un nuovo contenuto del post.
Sono deliziose riflessioni di titolo sulle mele.
OK, ora che ci siamo assicurati che i nostri
due modelli funzionino correttamente, possiamo creare un post e possiamo creare un utente.
Ma attualmente non hanno nulla
a che fare l'uno con l'altro e vogliamo che abbiano una relazione, ricordiamo che vogliamo che un utente abbia o possedere molti post e un post appartenga a un utente.
Quindi questa è una relazione uno a molti.
E il modo in cui ti mostrerò di farlo è incorporando i dati invece di uno schema utente.
Quindi assomiglierà a questo.
Allora lo spiegherò tra un momento.
Avremo attributo di un post all'interno dell'utente e all'interno dell'attributo Post.
Avremo un sacco di post e per fare questo abbiamo
bisogno di aggiungere lo schema del post all'interno di un array.
Quindi, piuttosto che creare una
stringa o un numero o un booleano, stiamo dicendo a mangusta che vogliamo che sia una lista di post e dobbiamo scrivere schemi di post che confondono un po 'onestamente.
Vorrei che fosse solo il nome della modella, ma è solo il modo in cui è.
Deve essere il nome dello schema e abbiamo un altro problema che è che se
lo eseguiamo adesso non sapremo cosa è il post-chemio e questo perché lo stiamo definendo secondo.
Quindi, se stiamo incorporando i dati, dobbiamo prima definirlo.
Quindi definiamo lo schema del post e il modello del post e
quindi definiamo lo schema dell'utente e all'interno dello schema utente stiamo aggiungendo un attributo chiamato post che è una matrice di post.
Quindi, se lo facciamo, i nostri dati assomiglieranno a qualcosa del genere o avremo un nome
per un utente, facciamo una e-mail e io farò solo un nome ridondante e poi avremo anche post e posta una matrice.
e un contenuto e un utente possa avere molti post proprio così.
E all'interno di questo array abbiamo più post in modo che ogni post abbia un titolo
E così per ogni post che
otterremo sarà un nuovo post al posto dell'attributo posts di un particolare utente.
Quindi andiamo avanti.
Creiamo un utente e poi ti mostrerò come possiamo aggiungere un post a quell'utente in modo che possiamo semplicemente usare il nostro.
Charlie Brown qui.
Il nuovo utente è uguale a Charlie Brown.
Anche se cambierò alcune e-mail e nomi perché abbiamo già Charlie Brown nel database.
Andiamo con sono tutti a Hogwarts edu.
E poi cambieremo questo per essere la mia zia Granger.
Tutto ok.
Quindi abbiamo un nuovo utente e quindi aggiungere un post a quell'utente.
Tutto quello che devono fare è scrivere nuovi post utente che spingono perché è un array.
E spingo in un nuovo post e un post ha un titolo e il titolo
del mio prossimo post sarà come preparare la pozione di succo di poly e quindi il contenuto sarà solo scherzando.
La lezione di pozioni per imparare tutto bene.
Qualunque cosa non contenga davvero.
Quindi abbiamo un
titolo e alcuni contenuti e quindi inseriremo questo post in un nuovo utente che abbiamo definito qui.
E l'ultima cosa che dobbiamo fare è salvare un nuovo utente.
Quindi un nuovo utente che risparmia in questo modo.
E in realtà lo abbiamo già
scritto, quindi lo riutilizzerò e lo rimprovererò e ciò cercherà di salvarlo.
Se c'è un errore ci farà sapere.
Altrimenti ci mostrerà l'utente e
poi commenterà tutte queste cose quaggiù riguardo i post e basta salvarlo e vediamo cosa succede.
Quindi abbiamo il nostro schema post che hai definito,
quindi abbiamo lo schema utente e la nuova parte è proprio qui dove abbiamo una serie di post all'interno dell'utente.
E poi stiamo creando un nuovo utente e inserendo quel post nel modo giusto.
Facciamo un tentativo.
OK.
nuovo post.
E torniamo indietro a questo utente che stiamo stampando qui e-mail che ricordano a Hogwarts che è Hermione Granger e che invece di post abbiamo un
Quindi sta funzionando bene.
Ora proviamo qualcos'altro in cui
ho intenzione di commentare tutto questo e piuttosto che creare un nuovo utente, recuperiamo l'utente esistente.
Quindi ho intenzione di recuperare la sua estrazione.
Quindi lo farò con l'utente find.
E ho intenzione di usarne uno.
Altrimenti trovare mi darà una matrice e voglio solo una cosa indietro.
Quindi stiamo andando a fare non trovi che troverai
il nome di Hermione Granger e poi faremo il nostro errore standard di callback e chiameremo questo utente.
Spero che tu ti senta a tuo agio in questo momento.
Proprio qui il callback che scriviamo
praticamente ogni volta che facciamo qualcosa con Mongoose e poi lo faremo.
Se mai l'errore
di dialogo di consulenza
e poi Altrimenti, continueremo a bug utente e ho una staffa in più ho bisogno di sbarazzarsi di ogni andare.
Quindi questo è solo per trovarla la mia nuova schiena niente di nuovo.
Stiamo solo trovando un nuovo utente e funziona.
Facciamo tornare l'utente.
Il suo nome è la sua mente, e-mail i suoi soldi a Hogwarts.
OK ora supponiamo di voler aggiungere un altro post perché questo dovrebbe essere uno a molti.
Quindi un utente può avere più post.
Facciamolo ora.
il titolo è tre cose.
Quindi, all'interno del resto, una volta trovato l'utente, eseguiremo del codice per aggiungere un nuovo post e quindi sembra che questo
utente invii push come prima e questa volta inserirà un altro post in modo da spingere nel titolo e
Odio davvero e il contenuto sarà tanto più tanto più.
E Voldemort.
Va bene post molto creativo lì mi ricorda e andremo avanti e salvare questo.
Quindi dobbiamo ancora salvare un utente e poi aggiungeremo la nostra callback in seguito.
Un altro di questi errori.
E chiameremo di nuovo questo utente.
E invece di qui farà se errore di log console errore altrimenti annullare l'utente di registro.
Va bene quindi questo è ciò che alcune persone chiamerebbero callback.
Al diavolo abbiamo molte callback qui.
Abbiamo questo primo che trova la sua
mente nel trovare quell'utente che stiamo ricevendo e poi stiamo spingendo in un nuovo post.
Ma questo in realtà non aggiunge al database.
Dobbiamo quindi salvarlo.
E così facciamo il salvataggio dell'utente e questo utente qui.
Questi due si riferiscono all'utente che ritorna quando troviamo la sua
mente la prima volta e poi stiamo salvando e quindi questo utente si riferisce a ciò che ritorna dal salvataggio.
Quindi questo utente qui ora ha aggiunto il nuovo post e salvato nel database.
Sono i dati che ci vengono restituiti da Mongo e poi li stampiamo.
Proviamo ora.
Quindi permettimi di sbarazzarmi di questo primo log di controtrama.
Lascia stare così.
nostri account sui log.
Assicurati di non avere nessun altro codice in esecuzione che interferisca con i
Facciamolo.
Tutto ok.
Quindi quello che
vediamo è che stiamo stampando un singolo utente Hermione che ha due post come primo e il secondo e sono entrambi memorizzati all'interno dell'attributo post sul singolo utente.
Quindi è uno a molti.
OK.
Quindi questo è tutto quello che voglio mostrare.
Riflettiamo su questo brevemente.
Quindi siamo partiti da Mongoose e abbiamo due modelli indipendenti.
E poi li abbiamo associati aggiungendo questo array di schemi post allo schema utente.
Quindi ora un utente ha una serie di post e inizia a vuoto.
Ma poi ci siamo aggiunti spingendo in post dot push e
poi abbiamo salvato nel prossimo video per mostrarti un altro modo di associare i dati usando quelli che vengono chiamati riferimenti agli oggetti.