[MUSICA]
Nell'esercizio precedente abbiamo portato i nostri server di loopback fino ad un certo stadio.
Siamo ora in grado di collegare i nostri server di loopback al database mongolab,
il database funge da fonte di dati per i nostri server di loopback.
Definiamo anche gli elenchi controllati di accesso per controllare l'accesso al raggio,
resto sono qui, in parti con il nostro server di loopback.
In questo esercizio esploreremo le relazioni di loopback.
Ora possiamo definire i modelli e definire le relazioni tra i modelli.
Quindi, per esempio, prendiamo l'esempio di un commento.
Quando pubblichi un commento su un piatto, il commento è correlato al piatto.
Un commento appartiene a un piatto.
Allo stesso modo, un commento viene pubblicato da un utente specifico.
Quindi il commento appartiene alla relazione con questo specifico utente.
Ora, quando si guarda la relazione nella direzione inversa,
un piatto può avere più commenti associati ad esso, e
allo stesso modo, un utente potrebbe aver postato più commenti.
Quindi questi sono i più grandi tipi di relazioni che è possibile definire tra
i vari modelli all'interno del nostro server di loopback.
Inoltre vedremo l'uso di un loopback misto,
che ci consente di aggiungere proprietà aggiuntive ai nostri modelli.
Alla fine di questo esercizio avrai un server loopback praticamente completo,
che potremo quindi connetterci al nostro client angolare ed
essere in grado di utilizzarlo come back-end per il nostro client angolare.
Per continuare con l'esercizio, nella cartella del nostro server di loopback
creiamo un nuovo modello per un commento.
Quindi questo modello definirà come
commento, e in questo caso quel modello viene salvato anche
in MongoDB e sarà come un modello persistente,
e esporremo il commento tramite l'API REST e
la cartella del modello è nella cartella comune e per
questo commento avremo due proprietà associate a esso.
E la prima proprietà è Valutazione.
Che è del tipo Number.
Questo è richiesto e il valore predefinito, lo lascerò come 5.
E la seconda proprietà sarebbe Comment, che è della stringa di tipo.
Questo è obbligatorio e il valore predefinito è vuoto.
Quindi ogni commento avrà queste due proprietà, valutazione e commento,
associate ad esso.
Inoltre, dobbiamo ora definire la relazione tra il commento e
l'utente che sta inviando il commento, e anche il commento e
il piatto con cui questo commento è associato.
Allo stesso modo, abbiamo visto nell'esercizio precedente che hanno aggiunto
i loro preferiti per un utente.
Quindi, per definire i preferiti, lasciami ancora definire un modello,
e quel nome del modello è Favorite e questo è anche salvato in MongoDB,
e questo è anche un PersistedModel, e
esporremo il favorito per il resto API ed è nella cartella comune.
Ora il favorito in sé non ha bisogno di alcuna proprietà specifica perché tutto
il favorito fa è associa l'utente specifico a questo piatto specifico.
Quindi il favorito qui sta per essere usato semplicemente come un ponte tra l'utente
e il piatto.
Quindi useremo il favorito come un modo per definire le relazioni tra il piatto e
un utente.
Quindi non ha proprietà specifiche.
Così ora abbiamo aggiunto due modelli nel nostro server di loopback.
Ora, iniziamo a definire le relazioni del modello.
Ora, come ho spiegato in precedenza,
ci sono vari tipi di relazioni modello che possiamo definire.
Iniziamo con la definizione del rapporto tra un piatto e un commento.
Quindi, per definire un modello in loopback, diremo, relazione lb.
E quando arriva la relazione,
dobbiamo specificare il modello da cui creare la relazione.
Quindi, in primo luogo, creeremo una relazione tra un piatto.
Quindi dai piatti, e un piatto potrebbe avere molti commenti associati con esso,
quindi è per questo che il tipo di relazione ha molti
ed è associato con un commento e il nome della proprietà per
la relazione lo lascerò come predefinito con solo commento con
una piccola lettera c. specifica chiave esterna personalizzata se vogliamo.
Se non lo facciamo, loopback assegnerà automaticamente la chiave esterna,
che non sarebbe altro che i commenti e un ID ad essa associato.
Quindi guarderà indietro per definirlo automaticamente.
Possiamo anche avere attraverso modelli, che in questo caso non è applicabile.
Un modello attraverso ci permetterà di definire la relazione con uno e con un altro modello e
in questo caso, non abbiamo tale relazione, quindi diremo solo di no e
non nidificheremo l'API REST, e inoltre,
disabiliteremo la relazione da includere.
E così, abbiamo specificato
che la disabilitazione della relazione dall'essere incluso è no.
Più tardi vedrai perché questo è importante.
Avremmo un modo di includere informazioni da un
modello in un altro modello facendo un inclusione lì.
Questo è un aspetto che abbiamo chiesto di non essere impedito.
Ora allo stesso modo, possiamo definire il prossimo rapporto
tra commento e piatti.
Quindi, quando si definisce una relazione con il commento e i piatti, quindi
lasciatemi dire lb relazione, e ora definiremo la relazione tra il commento.
E poiché un commento può appartenere solo a un piatto specifico, quindi
definiremo che appartiene a una relazione, e questo appartiene
al piatto qui e il nome della proprietà per la relazione sarebbe piatti.
E non useremo una chiave esterna personalizzata,
permetteremo che la relazione venga utilizzata nelle API REST.
In realtà non lo vogliamo, quindi avrei dovuto digitare no per quello,
ma andrò e modificherò la relazione creata nel mio codice lì.
Quindi posso andare nel file comment.jason e
cambiarlo da un sì a un no lì dentro,
lo farò perché non voglio che venga nidificato dopo.
Quindi lasciami andare avanti e
fare quel cambiamento nel commento chiamato Jason prima che mi dimentichi di farlo.
E poi apri il commento chiamato Jason.
E vedi che nel commento chiamato Jason abbiamo questa relazione qui e
poi ho intenzione di tagliare questo fuori perché non voglio che il nidificazione sia fatto.
Questo è un errore che ho fatto durante la digitazione, quindi lo cancellerò.
La prossima relazione che ho intenzione di definire è tra il commento e
il cliente.
Permettetemi di nuovo, digitate lb relazione qui.
Quindi definiremo il rapporto tra il commento e il cliente.
Un commento appartiene a un cliente come ci aspetteremmo,
e, Qui lasciami
entrare esplicitamente, Una chiave esterna personalizzata.
Lo sto facendo solo per illustrarti che posso
definire una chiave esterna specifica qui.
Non nidierò, e non disabiliterò qui.
Quindi, questa è la relazione che definirò tra il commento e
il cliente.
Successivamente, Permettetemi di definire la relazione tra il cliente e il commento.
Quindi qui, da un cliente, un cliente ha molti commenti,
e il loro nome della proprietà inserirò come commenti.
E poi, definirò la chiave esterna come CustomerID.
E non ho bisogno di un modello passante qui, non nidierò e non disabiliterò.
Così ora ho definito tutte le relazioni tra i commenti e
il cliente, e i commenti e i piatti.
Ora, la stessa cosa lavoriamo sui preferiti.
Ora, per i favoriti, Permettetemi di definire
il rapporto tra i piatti e i preferiti.
Quindi un piatto avrebbe potuto essere favoriti per molti utenti,
quindi ha molte relazioni con un favorito.
E useremo i preferiti lì, e
non avremo bisogno di un modello passante e no e no.
Quindi, ora abbiamo definito che ha molte relazioni tra il piatto e
un favorito.
Permettetemi ora di definire una relazione tra un favorito e un piatto.
Quindi, per definire il rapporto tra il favorito e
il piatto fammi dire preferito appartiene al piatto, e
useremo i piatti e nessuna chiave esterna, non annidata.
E non disabiliteremo la relazione da includere.
Ora, dovremo definire quella relazione tra
un favorito e un cliente.
Quindi diremo preferito appartiene a un cliente e,
Lo definiremo chiave esterna come CustomerID.
Non consentiremo la nidificazione dell'API REST e non disabiliteremo.
Ora l'ultima relazione, e' tra il cliente e il favorito.
Quindi, ora definiremo la relazione tra il cliente ha molti,
Preferiti, e questo,
definirò il CustomerID come chiave esterna, non ho bisogno di un modello passante,
e non permetterò il nidificazione e non disabiliterò nulla.
Così è tutto, abbiamo definito tutte le relazioni di cui abbiamo bisogno
tra i commenti e i clienti e i piatti.
Tra i favoriti, i clienti e i piatti.
Ora, esaminiamo l'uso di un mixin.
Ora, questo mixin che userò con il mio server Loopback è
un mixin che aggiunge timestamp a tutto ciò che viene salvato o aggiornato.
Quindi ricordate che nel nostro server Express, abbiamo creato e
aggiornato a aggiunto automaticamente utilizzando Mongoose.
Ora per Loopback, ho bisogno di usare questo
mixin specifico chiamato come Lookback ds timestamp mixin.
così tosDo che devo prima installare il mixin nel mio progetto.
Quindi dirò npm install
loopback-ds-timestamp-mixin —save
e installare questo modulo nodo.
E una volta installato questo modulo nodo, così come puoi vedere,
questo è il numero di versione 3.4.1 che sto usando.
Poiché questo mixin è installato, ho bisogno di entrare e
abilitare questo utilizzo mixin all'interno dei miei modelli.
Per fare ciò andiamo al codice, nel codice lasciami prima aprire
quel conflitto di modello adiacente, che si trova nella cartella del server.
Quindi nel modello confi.json se vai qui vedrai questi
mixin definiti qui.
Quindi abbiamo i mixin dal server loopback comune e loopback.
Ora ho intenzione di aggiungere il nuovo mixin che ho appena aggiunto qui.
Quindi, questo mixin è in.. /node_modules.
Quindi questo è nella cartella dei moduli del nodo proprio lì.
/loopback-ds-timestamp-mixin.
Ciò consente al mio server Loopback di fare uso di questo mixin all'interno del mio server.
Ora non solo questo, ho bisogno di specificare per
tutti i modelli in cui voglio che questo mixin sia incluso.
Quindi, andrò ora a quella cartella comune, e
nella cartella comune modificheremo quel file comment.json e
nel file comment.json, aggiungeremo nel mixin.
Quindi, dopo le proprietà, aggiungerò il mixin come
sincronizzazione tra virgolette, dirai mixins.
:, E, lì,
e all'interno dei mixins vedremo
TimeStamp, vero.
Questa stessa cosa che ho bisogno di incollare in alcuni degli altri modelli, quindi
lasciami copiare questo.
Quindi diremo mixins TimeStamp vero in comments.json.
Poi andremo a dishes.json e
poi aggiungeremo questo anche a dishes.json e
poi andranno a favorite.json, e
poi aggiungeremo in favorite.json.
Lo aggiungeremo a readers.json, E
lo aggiungeremo a promotions.json.
E salva tutte le modifiche.
Ora configureremo un altro elenco di controllo degli accessi, quindi
andando al terminale fammi digitare lb acl per configurare alcune liste di controllo di accesso.
Quindi, qui per i piatti,
specificherò per tutti i metodi e le proprietà il diritto
Può essere fatto solo dall'utente con l'amministratore del ruolo.
Quindi questo è il primo controllo di accesso che configuro per
i piatti, poi faccio lo stesso per i leader.
Tutti i metodi e le proprietà, scrittura, altro,
il ruolo di amministratore concedono esplicitamente l'accesso.
Quindi per le promozioni anche,
lo stesso, tutti i metodi e le
proprietà, scrivere, e altro,
Ruolo concedere esplicitamente l'accesso, perché si desidera solo che l'amministratore
sia in grado di apportare modifiche ai piatti, promozioni, o leader.
Ora per i commenti, i commenti possono essere pubblicati da qualsiasi utente registrato.
Quindi, per i commenti, permettetemi di definire l'ACL per i commenti.
Diciamo commento, tutti i metodi e le
proprietà, tutti i tipi, tutti gli utenti,
negano esplicitamente l'accesso.
Perche' non vogliamo che siano in grado di fare tutte le cose.
Ora, apriamo solo alcune delle operazioni da abilitare dagli utenti.
Quindi, per i commenti, tutti i metodi e
le proprietà, diremo operazione di lettura. L'
operazione di lettura per i commenti sarà solo un utente autenticato.
Quindi solo gli utenti che hanno effettuato l'accesso saranno in grado di leggere i commenti.
Ora allo stesso modo, permettetemi di definire per il
, Commenti, un singolo metodo e
creare, chi può creare commenti?
Qualsiasi utente autenticato, qualsiasi utente autenticato può creare commenti.
Quindi concederemo loro esplicitamente l'accesso, ora,
l'ultimo per i commenti, Diremo per
il commento, tutti i metodi e le proprietà.
Scrivi, il che significa che, a chi è permesso scrivere il commento?
Solo l'utente che possiede tale oggetto può apportare modifiche al commento.
Quindi solo l'utente che ha inviato il commento può apportare modifiche al commento,
sia modificare o eliminare il commento, quindi questo è ciò che permetteremo.
Stesso insieme di operazioni, applichiamo ai preferiti.
Quindi per i preferiti, dal momento che non abbiamo aggiunto
nessuno dei controlli di accesso, quindi per i preferiti, tutti i
metodi e le proprietà, tutti i tipi,
tutti gli utenti, negano esplicitamente l'accesso lì.
Per i preferiti, definiremo per
tutti i metodi e le proprietà, leggere,
solo per l'utente che possiede quell'oggetto.
Quindi solo l'utente può leggere
i propri preferiti, nessun altro utente dovrebbe essere in grado di vedere i propri preferiti.
Ora il terzo è la creazione di preferiti,
quindi per la creazione di preferiti, diremo per
preferito, un singolo metodo, crea,
qualsiasi utente autenticato può creare un commento.
E ultimo, per un favorito, tutti i metodi e
le proprietà, l'operazione di scrittura, solo per l'utente che possiede quell'oggetto.
Quindi solo l'utente che ha inserito il favorito per
se stesso può modificare o eliminare quei preferiti, il gioco è fatto.
Quindi ora abbiamo impostato tutti i controlli di accesso e
tutte le varie relazioni per la nostra applicazione.
Iniziamo ora l'API Rest del server e
quindi esplora alcuni di questi dettagli.
Ora, andando alla nostra applicazione nel browser, quindi
andremo a quel LoopBack Explorer nel browser qui.
In LoopBack Explorer, quello che farò prima è accedere come amministratore.
Quindi accederemo come amministratore andando al /clienti/login.
E poi qui scriveremo nome utente,
Admin, Password,
Password, E accederci,
e una volta che abbiamo effettuato l'accesso, ho solo intenzione di copiare questo ID,
perché questo è il token di accesso.
E andrò qui, e poi impostare il token di accesso con
questo nuovo token di accesso che ho appena ottenuto, dopodiché,
Lasciami postare alcuni piatti sul mio server, quindi
ora che ho effettuato l'accesso come amministratore,
dovrei essere in grado di postare piatti sul mio server.
Quindi aprirò il post e ricorderò che ti avevo dato il file db.json,
quindi possiamo semplicemente copiare e incollare i piatti nel campo dati qui.
Questo è il mio primo piatto, e nel momento in cui posto,
tornerà con le informazioni del piatto qui.
E nota che aggiunge automaticamente nei campi CreateDat e UpdateDat qui.
Questo è il mio secondo piatto, quindi finalmente, ho completato l'inserimento di
tutti i piatti, tutti i leader e tutte le promozioni, e abbiamo finito.
Quindi andiamo avanti e
poi registrare un nuovo cliente nel sistema.
Quindi, per farlo, lasciami rimuovere questo
token di accesso e quindi registreremo un nuovo cliente nel sistema.
Quindi, per farlo, andremo a pubblicare i clienti, e poi per i dati,
lasciatemi fare clic su questo valore di esempio qui, e poi pubblicarlo qui.
E per i dati, il nome,
fammi registrare con il mio nome.
Quindi questo sarebbe un
utente non amministratore che sto registrando, e,
E questa e-mail verificato dovrei rimuovere questo da qui, Ma dovrei includere il
campo password qui, in modo che io possa registrare l'utente.
Quindi sto registrando un nuovo utente ordinario qui.
Quindi, quando mi registro, torna per confermare che questo nuovo
utente registrato è stato aggiunto e mi dà anche un ID per quell'utente.
Ora lasciami accedere come questo utente registrato e poi postare un paio di commenti.
Quindi, per accedere come utente registrato, scenderò al login del cliente,
e per il nome utente, scriverò il mio nome e
la password e poi quando effettuerò il login, tornerà e mi darò un ID.
Ora nota che questo particolare utente è un utente ordinario e non un amministratore,
quindi questo utente può solo pubblicare commenti e modificare i propri commenti.
E o post-favoriti e modificare i propri preferiti.
Quindi, quando pubblichi l'utente, vedrai che è l'ID utente restituito qui,
shis è l'ID per l'utente.
Quindi, avremmo bisogno di questo ogni volta che pubblichiamo commenti o
ogni volta che pubblichiamo i nostri preferiti.
Quindi, per pubblicare un commento per questo utente, quindi
per pubblicare un commento, lasciami pubblicare un paio di commenti per conto di questo utente.
Quindi, andremo a Commenti, e poi pubblicheremo alcuni commenti qui.
Quindi, per pubblicare un commento come si nota,
abbiamo bisogno di fornire tre informazioni.
Dobbiamo fornire il CustomerID, il DisheID, la valutazione e il commento.
Quindi, per il CustomerID, abbiamo appena effettuato l'accesso, quindi
se vai dai clienti e quaggiù in basso.
Otterremo il CustomerID qui, quindi lasciami copiare l'ID utente da qui.
E poi vai nella sezione di pubblicazione dei commenti e
quindi incolla il CustomerID lì.
Lasciami andare a cercare un piatto.
Quindi, se si va a, Piatti e poi si fa un get sui piatti,
si otterrà tutti i piatti che sono nel sistema.
Quindi da questo mi permetta di selezionare il,
Primo piatto, quindi mi limiterò a prendere l'ID del piatto.
Poi per pubblicare i commenti, andremo solo a Commenti,
Post dove stiamo componendo il nostro commento.
E poi incollero' il documento del piatto li' dentro.
E per la valutazione, Cambierò questa valutazione a 4 e,
Basta pubblicare, Questo commento,
così ho postato un commento per questo piatto particolare.
Permettetemi di postare un altro commento per un altro piatto.
Quindi fammi prendere questo secondo piatto.
Quindi ecco l'ID del secondo piatto quindi, ancora una volta, tornando a Commenti.
Fammi cambiare il DishID qui.
E poi, Mi permetta di cambiare i commenti in modo
che si vede che questo è un commento diverso per un piatto diverso.
Quando pubblico il commento, vedrai che tornerà con questa risposta qui,
con la valutazione e il piatto specifico e il CustomerID e così via.
Quindi ora ho postato due commenti per due piatti diversi qui.
Lasciatemi fare questi due come i miei piatti preferiti.
Quindi, per farlo, lasciami andare a Preferiti.
Scendendo ai preferiti.
Permettetemi di postare un paio di preferiti.
Quindi, per pubblicare di nuovo un favorito, vado nei preferiti post qui.
Quindi clicco su questo e poi incollerò in un
dishId, per il CustomerID, fammi solo andare al cliente qui,
dove ho effettuato l'accesso al cliente.
Quindi otterremo l'ID utente da lì.
E questo è un CustomerID, quindi lasciami andare ai Preferiti.
E poi, Nei Preferiti
fammi testare il CustomerID qui, e poi postare questo nei miei preferiti.
Quindi, quando lo posto nei miei preferiti, risponde con questo in modo da
poter vedere che dishId e customerID e FavoriteId sono stati pubblicati qui.
Lasciatemi postare un altro piatto ai miei preferiti in modo da lasciarmi andare al,
Piatti qui ho un altro piatto.
Quindi fammi copiare il, ID del piatto e andare ai miei preferiti e
poi sostituire l'ID di dishe con quel nuovo piatto, e poi postarlo.
Quindi ora dovrei avere due favoriti nel mio gruppo.
Meraviglioso, quindi ora abbiamo un paio di preferiti,
un sacco di piatti, un paio di commenti, tutti postati in.
Ora, come è utile?
Lasciami, Chiudi tutto questo e poi ti mostrerà come questo può essere utile.
Quindi, ora quando ho i piatti, quindi per esempio,
quando voglio dimenticare un piatto specifico.
Fammi prendere questo primo piatto qui, fammi copiare l'identita' del piatto e
posso recuperare quel piatto specifico.
Quindi qui vedi che sto andando a/dishes/id così
qui, quando voglio recuperare quel piatto specifico.
Posso mettere il dishId lì e poi provarlo e
poi qui ottengo il dishId qui.
Ora, se voglio includere i commenti dal piatto, quindi nel filtro,
dovrei digitare includi tra virgolette e
poi tra parentesi specifichi,
Il nome di,
La relazione che voglio includere in quello,
quindi quando dico includi commenti.
Quindi questo è come popolano i mongoli, agisce allo stesso modo.
Quindi, quando dico di includere commenti e poi recuperare il piatto,
notare che quando il piatto viene recuperato,
qui, si ottiene il piatto, ma anche si ottiene una serie di commenti qui.
Quindi è così che puoi compilare i dettagli dalla relazione
che hai con un altro elemento qui.
Ora, allo stesso modo, andando ai commenti, per esempio.
Nei commenti anche, quando recupero i commenti, posso specificare all'interno del filtro.
Quindi, quando dico solo commenti GET,
riporterà tutti i commenti che sono stati pubblicati.
Ora, se voglio compilare le informazioni dishID e customerID, posso dire filtro.
Nel filtro, posso dire includere.
E poi tra parentesi, posso dire piatti perché
questo è il rapporto che ho definito all'interno dei commenti e
dei piatti, e poi piatti e cliente.
E quando recupero queste informazioni, vedrai che nei commenti restituiti,
per ogni commento, noterai che il commento è dato e
quindi anche le informazioni relative al piatto sono compilate, e
le informazioni relative al cliente sono anche compilate per ciascuno dei commenti.
In questo modo, ora possiamo popolare le due relazioni che abbiamo definito
dai piatti automaticamente qui dentro, come mostrato qui.
Allo stesso modo, per i preferiti,
quando stiamo recuperando i preferiti,
diremo preferiti e un ID specifico qui.
E poi possiamo quindi filtrare, in modo
che il preferito specifico può essere recuperato.
Non è possibile recuperare tutti i preferiti perché potrebbero essere preferiti da altri
utenti anche in quell'elenco, quindi non saremo in grado di fare un GET su tutti i preferiti.
Ma invece, quando si recupera questo, si può quindi chiedere che
le informazioni vengano compilate qui in base alle relazioni.
Quindi possiamo dire, in virgolette, («include»: e parentesi quadre scritte.
Possiamo dire ["piatti», «cliente"]),
E recuperare le informazioni.
Quindi noteresti che qui, nel corpo di risposta,
ottieni il favorito, ma anche il piatto corrispondente e
le informazioni del cliente corrispondenti compilate qui.
Così è così che possiamo recuperare ulteriori informazioni
dal nostro sito server come richiesto.
Con questo, completiamo questo esercizio.
In questo esercizio, ho dimostrato a voi come possiamo definire varie relazioni
e quindi essere in grado di recuperare informazioni, e anche utilizzare questo
filtro include al fine di includere le informazioni aggiuntive di tale relazione nel
documento quando si recupera il documento o un insieme di documenti.
Con questo, completiamo questo esercizio.
Quindi, in questi tre esercizi che abbiamo fatto finora con LoopBack, ho
illustrato vari aspetti di come è possibile configurare e costruire il server LoopBack.
Con questo, completiamo questo esercizio.
Questo è un buon momento per
fare un commento GET con il messaggio relazioni LoopBack.
[ MUSIC]