Ora che abbiamo completato lo sviluppo di un server API Rest completo utilizzando LoopBack,
la prossima domanda immediata che sorgerà nella tua mente è,
come adattiamo l'applicazione Angular per fare uso di questo server API Rest?
Come abbiamo fatto nei casi precedenti,
avremo anche bisogno di riconfigurare la nostra applicazione angolare per fare uso specifico
degli endpoint API Rest e
le varie richieste API Rest come esposto dal nostro server LoopBack.
Ora, questo è dove trarremo vantaggio di
un SDK LoopBack che può essere costruito automaticamente per noi utilizzando un modulo Node.
Vedremo i nostri server LoopBack,
vari endpoint API Rest e costruiremo automaticamente l'SDK,
che possiamo quindi incorporare nella
nostra applicazione Angular e quindi essere in grado di comunicare con il nostro server LoopBack,
sia per l'autenticazione e anche per essere in grado di scambiare dati.
Per iniziare a questo esercizio,
clonare prima il repository git che contiene
un'applicazione Angular parzialmente completata che comunica con il nostro server LoopBack.
Quindi, per farlo, vai nella tua posizione comoda sul tuo computer.
Quindi, eccomi qui nella mia cartella Coursera Angular.
Ho intenzione di clonare il repository git
digitando git clone
https://github.com/jmuppala/conFusion-Angular6-LoopBack.git,
e poi clonare questo repository git.
Una volta che il repository git è clonato,
allora ci sposteremo nella cartella Confusione Angular6 LoopBack e quindi
eseguire un'installazione NPM per installare
tutti i moduli nodo per questa applicazione angolare parzialmente completata.
Per creare automaticamente il kit di sviluppo software LoopBack per il nostro server LoopBack,
prenderemo l'aiuto di questo modulo nodo LoopBack SDK Builder.
Quindi, questo LoopBack SDK Builder
è un modulo nodo guidato dalla comunità che è effettivamente sviluppato
dal LoopBack SDK Angular ufficiale che gli sviluppatori di LoopBack avevano rilasciato.
Il Loopback SDK Angular supportato Angular JS.
Quindi, questo è stato modificato in questo Loopback SDK Builder
per supportare Angular due e sulle applicazioni.
Quindi, il LoopBack SDK Builder,
il modulo nodo stesso una volta installato nella cartella del progetto del server,
quindi è possibile utilizzare LoopBack SDK Builder per
passare automaticamente attraverso l'applicazione LoopBack che è già stata creata.
Questo costruirà automaticamente tutto ciò di
cui abbiamo bisogno per iniziare con la nostra applicazione Angular.
Quindi, costruisce il kit di sviluppo software.
Quindi, all'interno del kit di sviluppo software,
LoopBack SDK Builder esporta
tutte le interfacce, tutti i modelli per i vari dati che stiamo per memorizzare sul
nostro server LoopBack e anche
tutti i servizi API che possono essere utilizzati all'interno dell'applicazione Angular.
Quindi, i tuoi modelli e i tuoi servizi vengono automaticamente per il viaggio una volta creato l'SDK.
Ora è solo questione di incorporare questo SDK nella nostra applicazione Angular
e quindi iniziare rapidamente.
Dal momento che abbiamo già costruito la nostra applicazione Angular in un corso precedente,
ho intenzione di retrofit quell'applicazione per utilizzare l'
SDK LoopBack che esporteremo da questo LoopBack SDK Builder.
Nel passaggio precedente,
hai appena installato
l'applicazione angolare parzialmente completata che è
già stata adattata per utilizzare l'SDK di LoopBack.
Quindi, andiamo avanti e costruiamo
il LoopBack SDK e quindi distribuirlo nella nostra applicazione Angular,
quindi andiamo avanti e compilare la nostra applicazione Angular e iniziare con esso.
Per configurare LoopBack SDK,
andare alla cartella del server LoopBack nella scheda terminale o nella finestra di comando.
Quindi eccomi nella mia cartella del server LoopBack.
Quindi, in questa cartella,
lasciami andare avanti e installare quel LoopBack
SDK Builder.
Una volta installato il builder,
andiamo avanti e costruiamo l'SDK di LoopBack.
Per costruire il LoopBack SDK,
prenderemo l'aiuto dello strumento da riga di comando LB-SDK che questo modulo LoopBack SDK,
configura automaticamente per noi.
Quindi, per accedervi, diremo,. /node moduli.
Quindi, nei moduli del nodo,
c'è la cartella a.bin che viene creata automaticamente ogni volta che si
installano vari moduli nodo nella cartella lì.
Quindi, per andare alla cartella the.bin,
accederemo a questo comando LB-SDK lì,
che viene installato automaticamente,
quindi chiameremo questo server larghezza. /server.js,
e abbiamo bisogno di specificare il percorso per l'applicazione angolare che abbiamo appena configurato.
Quindi, la mia applicazione Angular è attualmente nei
miei documenti Coursera angolare Confusione cartella angolare LoopBack.
Quindi, fammi copiare quella parte.
Quindi lasciami andare nel mio terminale o nella finestra di comando
in cui sto cercando di configurare il mio SDK LoopBack.
Quindi, al prompt,
dal momento che è nella cartella I miei documenti,
ho intenzione di digitare il percorso completo di questo a partire dalla mia cartella principale nel mio mac.
Se si utilizza Windows,
assicurarsi che questo percorso indichi il percorso completo a partire dai due punti C o dai due punti D, a
seconda di quale unità si sta installando sul computer Windows.
Quindi, il percorso completo della cartella LoopBack angolare,
e quindi diremo,
/SRC, la cartella di origine lì, e quindi app.
Quindi, stiamo andando a distribuire l'SDK
nella cartella condivisa nella sottocartella SDK lì.
Vogliamo che questo LoopBack SDK Builder
distribuisca automaticamente la versione Web NG2 dell'SDK.
Quindi, questa è la versione che supporterà
le applicazioni web e la nostra applicazione Angular in questo caso.
Se stai costruendo questo per un'applicazione script nativa, allora dirai,
NG2 nativo per creare l'SDK per l'applicazione Native Script.
Dal momento che sto costruendo la mia applicazione Angular,
dirò semplicemente, NG2 web,
e poi lascio che Loopback SDK Builder
crei automaticamente il kit di sviluppo software e quindi lo distribuisca
nella mia cartella app/condivisa/sdk di origine delle applicazioni Angular lì.
Quindi, dopo alcuni secondi,
l'SDK viene creato e distribuito nella mia applicazione Angular.
Ora, prima di avviare la mia applicazione Angular,
lasciami avviare il mio server LoopBack,
e prima di farlo andrò in un'altra scheda terminale
qui e poi avviare il mio server MongoDB,
così bene dirò,
Mongod —dbpath=data, e quindi
avviare il mio server MongoDB.
Innanzitutto, fammi avviare il mio server LoopBack.
Quindi, al prompt NPM start,
e il mio server LoopBack dovrebbe essere attivo e in esecuzione in breve tempo.
Quindi, ora andando alla mia applicazione LoopBack,
lasciami aprire questa applicazione nel
mio codice di Visual Studio in modo che possiamo guardare il codice sorgente.
Una volta che la mia applicazione è aperta nel codice di Visual Studio,
lasciami prendere in una nuova finestra desktop.
Quindi, fammi anche avviare la mia distribuzione dell'applicazione Angular
digitando ngServe al prompt e attendere che la mia applicazione Angular venga compilata.
Una volta che la mia applicazione Angular è stata compilata e applicata,
lasciami andare su un browser
e quindi prima eseguire il checkout di questa applicazione Angular.
Andando al browser,
lasciami aprire una nuova scheda qui,
e quindi digita localhost: 4200 e vedrai
l'applicazione angolare distribuita a questa finestra del browser qui,
e puoi vedere che la Home,
la pagina Chi siamo con tutti i dati,
quindi il Menu e anche i Miei Preferiti.
Attualmente che non mostra nulla perché
nessun utente è connesso e la pagina dei contatti, proprio come prima.
Quindi, per accedere, lasciami accedere come utente e poi scriverò il
mio nome utente e una password qui,
e poi una volta effettuato l'accesso, sarai in grado di vedere che quando vado a I miei preferiti,
i Preferiti di questo particolare utente verranno visualizzati qui.
Proprio come prima, possiamo digitare commenti e quindi inviare commenti,
e quindi anche aggiungere elementi ai preferiti e così via.
Tutte le funzionalità che avete visto con le versioni precedenti
dell'applicazione Angular sono supportate anche in questa versione dell'applicazione Angular.
Anche affinché il tuo server LoopBack sia in grado di servire immagini,
tutti questi dati verranno memorizzati nel codice del server nella cartella client del codice server.
Quindi, nella cartella client del mio server LoopBack,
si noti che ho creato questa sottocartella
denominata immagini e quindi memorizzato tutte le immagini nella sottocartella.
Ora, affinché queste immagini vengano servite e anche
la cartella client venga utilizzata come cartella pubblica per il mio server LoopBack,
quindi in un paio di modifiche che devo apportare al mio server LoopBack.
Ora, la prima cosa che devi fare è
andare nella cartella di avvio e nella cartella di avvio,
vedresti questo file root.js qui,
che contiene queste informazioni qui.
Ora, puoi eliminare il file root.js
o semplicemente rinominare il file root.js in qualcos'altro.
Quindi qui, vedi che ho rinominato questo file in root.jsold con l'estensione jsold.
Ora, questo file non dovrebbe più contenere l'estensione the.js.
Quindi, qualsiasi cosa diversa dall'estensione the.js va bene.
Quindi, ciò significa che in questo caso,
il mio server LoopBack, all'avvio non eseguirà il codice in questa cartella.
Ora, quando guardi il codice nel file root.js che è stato configurato in precedenza,
hai visto che il router è stato configurato in modo tale che,
quando accedi alla barra che è la cartella principale dei tuoi server,
allora sarà semplicemente servire lo stato dei server LoopBack e in effetti,
questo è ciò che abbiamo visto il nostro server LoopBack serve
l'uptime e l'ultimo tempo di riavvio per il nostro server.
Non vogliamo che lo faccia,
invece vogliamo che il nostro server LoopBack sia in grado di utilizzare qualsiasi cosa abbiamo
inserito nella cartella client come cartella pubblica e quindi
qualsiasi applicazione client può essere distribuita
nella cartella client del mio server LoopBack e dovrebbe essere
accessibile quando accediamo a LoopBack ai suoi punti finali della barra standard.
Quindi, questa è la radice della cartella del server.
Quindi, per farlo, la prima cosa che devi fare è
cambiare questo nome di file root.js in root.
ad esempio, puoi semplicemente rinominarlo in
root.jsold o puoi semplicemente eliminare quel file.
Tale file non sarà necessario in questa versione del mio server LoopBack.
Ora, non solo,
la seconda parte che devi riconfigurare è andare nel file middleware.json qui.
Il file middleware.json.
Nel file middleware.json,
se scorri verso il basso,
vedrai che qui,
originariamente questo conterrà semplicemente i file: e poi una parentesi vuota qui.
Ora, in quella parentesi vuota
qui, aggiungi questo codice qui,
che dice loopback #static e dice parametri $!.. /client.
Quindi, questo indicherà al mio server LoopBack
che la cartella client che è disponibile qui
dovrebbe essere utilizzata come cartella pubblica statica per il mio server LoopBack.
Quindi, qualsiasi cosa inserita nella cartella client è accessibile dal mio server.
Quindi, questa è la modifica aggiuntiva che devi fare al file middleware.json.
Quindi, una volta che si eseguono queste due modifiche,
il server LoopBack sarà tutto configurato per servire i dati, incluse
le immagini che si sta andando a mettere
nella sottocartella immagini sotto la cartella client qui.
Quindi, assicurati di copiare le immagini nella cartella client qui e il secondo è quello di
andare al file middleware.json nella cartella server
e quindi aggiornare questa parte.
Una volta fatto questo, allora queste immagini possono essere accessibili semplicemente accedendo
al /images/ il nome del file immagine per accedere a
queste immagini perché i nostri piatti
, leader e le promozioni richiedono questi file immagine e
così che sarà disponibile per noi
dal server LoopBack e anche qualunque cosa tu abbia inserito nella cartella client.
Quindi, ad esempio, è possibile preparare la cartella di distribuzione
per l'applicazione Angular e semplicemente copiare
l'intero contenuto della cartella di distribuzione nella cartella client qui,
e quindi se si accede al server LoopBack nel
suo endpoint radice standard,
l'applicazione Angular sarà servito automaticamente dal server LoopBack.
Quindi, queste sono le due modifiche che è necessario apportare al server LoopBack.
Ovviamente, devi essere curioso di sapere come è costruito esattamente questo SDK,
dove esattamente è questo SDK e come
farò effettivamente a utilizzarlo all'interno della mia applicazione Angular.
Quindi, per fare ciò, andiamo alla nostra applicazione Angular e nella cartella sorgente,
sotto la cartella dell'app di origine,
ora quando apri la cartella condivisa,
vedrai che c'è una sottocartella qui denominata SDK e all'interno di questa sottocartella SDK,
troverai un sacco di file qui,
lb.config.ts, index.ts e all'interno dei socket di archiviazione,
dei servizi e all'interno del servizio,
sono disponibili servizi personalizzati e servizi di base qui
e i vari modelli che vengono distribuiti qui.
I modelli contengono effettivamente le strutture del modello
per i nostri vari modelli che stiamo implementando.
Ora, questo è l'SDK di LoopBack.
Questo codice viene creato automaticamente per te e, se vuoi,
puoi semplicemente entrare e
passare attraverso questi file per vedere solo ciò che è disponibile lì.
Assicurarsi di non modificare nessuno dei file in
questa sottocartella SDK perché questo viene
creato automaticamente dal Loopback SDK Builder
e questo conterrà tutto ciò che è configurato in modo che
il server LoopBack sia accessibile dall'applicazione Angular.
I servizi che farò uso sono tutti disponibili qui.
Ora, come facciamo a sfruttare questo?
Quindi, per aiutarti a capire come facciamo uso di questo,
visitiamo il nostro componente di casa e poi vediamo come il componente di casa è ora aggiornato.
Quindi, quando vai al componente di casa,
noterai che ora sto importando piatti da.. /shared/sdk/models.
Quindi, questi sono i modelli che vengono automaticamente esportati
nell'SDK dal mio Loopback SDK Builder.
Quindi, questo è dove il mio modello di piatti sarà definito lì.
Quindi, ho intenzione di sfruttare il modello dei piatti.
Allo stesso modo, il servizio stesso è disponibile come questo DishesAPI,
come puoi vedere qui e questo DishesAPI è nel.. /shared/sdk/services cartella qui.
Allo stesso modo, le promozioni e le promozioni API,
e leader e leader API.
Quindi, questi sono tutti costruiti automaticamente per me dal Loopback SDK Builder.
Ora, poi vai nel codice,
ora noterai che dichiarerò il piatto come piatti,
promozione come promozioni, e leader come/leader.
Questi tre sono i modelli esportati da Loopback SDK Builder.
Si noti anche come ho riconfigurato i tre servizi qui.
Ora, il mio servizio di piatti si riferisce all'API dei piatti,
ai servizi di promozione che si riferiscono alle API delle promozioni
e al servizio leader dell'API dei leader,
e noto anche come accedo al servizio piatto qui.
Quindi, dirò che questo servizio piatto trovare uno e dove caratterizzato uguale a vero.
Quindi, questo è dove ricordi che nel mio LoopBack riposo API Explorer, l'
avevo digitato nel filtro lì,
quindi ho provato a trovare i piatti lì.
Quindi, questo è esattamente quello che sto facendo qui anche nel mio codice qui.
Quindi, questo
findOne, quindi fornito con questo, troverà un oggetto e poi lo restituirà qui,
e poi che sto assegnando ciascuno a questo piatto qui e
il resto della mia applicazione Angular funziona esattamente allo stesso modo di prima.
Ora, si noti anche che nel costruttore,
si noti come ho configurato questo chiamato LoopBack config.
Ora, per eseguire la configurazione di LoopBack in ogni componente di cui si sta facendo uso,
è necessario importare questa configurazione di LoopBack da questa cartella SDK condivisa qui e anche,
questa versione API che dichiaro.
Ho aggiornato questo file baseurl.ts.
Quindi nella cartella URL di base,
ho aggiornato questo al mio nome dei due punti del computer 3.000.
Quindi, questo assicurati di sostituirlo con
l'indirizzo IP o il nome del tuo computer specifico su cui stai eseguendo.
Quindi, assicurati di aggiornare l'URL di base qui e la versione API qui è semplicemente una stringa.
Dire API qui.
Quindi questi due verranno utilizzati nel mio file component.ts di casa.
Quindi sto importando questa versione API qui e LoopbackConfig.
Il BaseURL che sto già iniettando
nel mio costruttore qui in modo che sia già disponibile qui,
e quindi nel mio costruttore del mio componente,
ho bisogno di fare queste due istruzioni qui.
Quindi, diremo, «LoopBack imposta l'URL
di base sull'URL di base» che è lo stesso di quello che ho appena
iniettato lì e poi guardare indietro sulla versione API impostata su versione API qui.
Quindi questi due ho bisogno di configurare nel mio componente di casa
e anche qualsiasi altro componente in cui sto accedendo al mio server LoopBack,
ho bisogno di configurarlo.
Ora, il costruttore di SDK di LoopBack suggerisce che dobbiamo
farlo in ogni singolo componente qui.
Inoltre, noterai che se vai al file dell'app module.ts nel file dell'app module.ts,
ho rimosso tutti gli input di tutti gli altri servizi e invece sto importando
questo qui chiamato import SDK Browser module da share SDK qui.
Modulo Browser SDK qui,
e se vai giù negli input qui,
vedrai che ho configurato questo modulo Browser SDK. ForRoot qui negli input.
Quindi questo modulo SDK Browser viene configurato automaticamente quando costruiamo il nostro SDK LoopBack e
abbiamo solo bisogno di importarlo nel nostro
file module.ts dell'app e anche notare che i fornitori,
qui è dove abbiamo configurato i nostri servizi,
non contiene più nessuno dei servizi perché
viene come parte del mio SDK LoopBack,
quindi l'unica cosa che sto fornendo è l'URL di base qui.
Ho rimosso tutti gli altri dal mio file module.ts dell'app qui.
Quindi, questo è un cambiamento che noterete.
Quindi, allo stesso modo, se si va al file Informazioni su component.ts,
il file component.ts DishDetail,
il file component.ts dei preferiti e anche il file component.ts del menu.
Quindi diamo un'occhiata al file component.ts del menu.
Quindi vedrai qui di nuovo che sto importando questi
quattro e poi nel mio componente di menu sto dicendo,
API per piatti dei servizi Dish e poi sto
configurando la versione del set di LoopbackConfig BaseUrl SetAPI.
L' ho già fatto nel repository Angular che
ti ho fornito per la mia applicazione angolare per il server LoopBack,
e inoltre, vedrai che ho appena apportato alcune modifiche qui.
Quindi, se si desidera trovare tutti gli elementi dal servizio piatto in modo da dire semplicemente
dishservice.Find e che restituirà
tutti i piatti che ci sono nel mio server LoopBack qui.
Quindi e' quello che sto recuperando qui.
Quindi il resto del codice dovrebbe apparire familiare qui tranne che qui chiamo
piatti è uguale a piatti e matrice di piatti qui.
Quindi questo è il cambiamento che vedrete nel componente del menu.
Ora, devi chiederti come funziona l'autenticazione utente in questo caso.
Per l'autenticazione utente, consentitemi di attirare la vostra attenzione su
due punti in cui sto facendo uso dell'autenticazione utente.
Andiamo prima al componente di login.
Quindi, nel componente di accesso,
vedresti che nel componente di accesso sto importando questi due qui,
l'API del cliente che è i servizi che mi consentono di
eseguire l'autenticazione utente e l'accesso e la disconnessione,
e anche sto importando il modello del cliente e il modello di
token di accesso e nel componente di login,
vedresti che dal servizio Auth ora non è altro che API del cliente e
inoltre noterai che nel componente di login quando viene inviato il modulo di login,
chiamo questo AuthService.Login.
Questa funzione di accesso è disponibile tramite l'API del cliente.
Ricordiamo quando abbiamo provato ad accedere utilizzando l'esploratore API di riposo LoopBack,
stavamo usando l'endpoint del cliente per accedere al sistema.
Quindi questo è esattamente quello che sto facendo nel codice qui.
Quindi diremo questo AuthService.Login e qui vedete
che ci vogliono questi parametri gratuiti qui,
il nome utente e la password come primo oggetto JavaScript qui,
e poi sto specificando anche questo user.remember., .remember è la bandiera
dalla casella di controllo Remember me che abbiamo nel nostro dialogo dei componenti di accesso lì.
Quindi, quando l'utente controlla che le informazioni dell'utente verranno
automaticamente mantenute dall'SDK.
Il servizio Auth fornito all'interno dell'SDK.
Quindi, ora vedi che non ho bisogno di
implementare esplicitamente alcun servizio di autorizzazione che è
automaticamente disponibile per me tramite
l'API del cliente disponibile come servizio qui.
Quindi, è così che accedo all'utente qui,
e quando l'utente accede a questo restituirà
un oggetto JavaScript e dall'oggetto JavaScript ottengo il
res.user.. l'utente fornisce le informazioni dell'utente per me e sto
semplicemente inviando questo al mio HeaderComponent qui.
Quindi andando nel HeaderComponent.
Quindi andiamo nel componente di intestazione,
e nel file HeaderComponent.ts,
vedrai che di nuovo qui sto importando l'API del cliente e il
cliente qui e anche noterai che nell'API del cliente,
specifico qui nota che sto dicendo che
questo cliente è questo AuthService GetCachedCurrent.
Quindi, se un utente è bloccato negli
utenti attualmente connessi, le informazioni vengono lanciate in AuthService che non è altro che l'API del cliente.
Quindi, quando chiamo questo getCachedCurrent questo restituirà l'utente attualmente connesso.
Se nessun utente è connesso,
questo restituirà null.
Quindi questo è un modo in cui posso verificare se un utente è attualmente connesso o meno.
Quindi, se l'utente è attualmente connesso, questo.customer
otterrà le informazioni sul cliente che viene caricato in.
Le informazioni del cliente, tra cui nome, cognome,
e-mail e il profilo dell'altro utente, saranno disponibili per questo oggetto questo.customer.
Quindi, qui sto controllando per assicurarmi che questo.customer non sia nullo.
Se non è nullo, salverò il nome utente su
this.customer.username e in questo modo quando
il nome utente è impostato, la mia intestazione nella
barra degli strumenti nel mio HeaderComponent rifletterà il nome dell'utente lì.
Ora, per disconnettere l'utente tutto ciò che sto facendo è che sto impostando il nome utente e
le variabili cliente su null e quindi ho semplicemente chiamato authService.log,
AuthServices è CustomerAPI.logout, ed è così che disconnetto l'utente.
Quando l'utente si disconnette,
le sue credenziali vengono distrutte.
Ora, tutto questo viene gestito automaticamente dal servizio API del cliente
disponibile nel mio SDK LoopBack che ho appena costruito lì.
Quindi, noti che come LoopBack SDK Builder costruisce i
servizi e i modelli e tutto ciò di cui ho bisogno e nella mia applicazione Angular,
sto semplicemente importando quelli e poi
facendoli uso per configurare la mia applicazione Angular.
Quindi, una volta creato
l'SDK LoopBack utilizzando LoopBack SDK Builder, tutto ciò che mi rimane è
l'implementazione dei componenti e dei loro modelli di visualizzazione che si trovano tutto il resto.
I servizi sono creati automaticamente per me da LoopBack SDK Builder,
i modelli vengono creati automaticamente per me e tutto ciò che devo fare è
importarli in tutti i componenti in cui ho bisogno di farne uso.
Quindi, si noti come questa applicazione angolare è stata aggiornata per fare uso di LoopBack SDK.
Ora, se si desidera ulteriori informazioni su come utilizzare LoopBack SDK,
è anche possibile consultare la documentazione fornita da LoopBack SDK Builder.
Pertanto, se si accede a LoopBack SDK Builder,
un collegamento a questo è disponibile nelle risorse aggiuntive per questa lezione
e nel LoopBack SDK Builder,
si dispone
di tutte le informazioni necessarie per utilizzare l'SDK creato da LoopBack SDK Builder.
Quindi se vai alla documentazione wiki.
Nella documentazione wiki molte spiegazioni di come può
essere LoopBack SDK Builder o che l'SDK generato da LoopBack SDK Builder dovrebbe essere usato è tutto qui.
Quindi, ho appena esaminato questa documentazione per capire come
utilizzare l'SDK creato da LoopBack SDK Builder,
e quindi riconfigurato la mia applicazione Angular per farne uso
per interagire con il mio server LoopBack.
Quindi con questo, ti ho rapidamente dimostrato come
puoi creare la tua applicazione Angular e
sfruttare l'SDK creato da LoopBack SDK
Builder per accedere al tuo server LoopBack dall'interno dell'applicazione Angular.
Un approccio simile sarà appropriato anche per l'applicazione ionica.
Per l'applicazione Native Script si crea l'SDK con NG2 nativo
nella riga di comando invece di NG2 Web come abbiamo usato quando abbiamo creato questo SDK.
Con questa rapida introduzione a come possiamo fare uso di
LoopBack SDK Builder per costruire l'SDK e
quindi utilizzarlo all'interno della nostra applicazione Angular,
arrivano alla fine di questo esercizio.