1
00:00:03,550 --> 00:00:06,360
Nell'esercizio precedente,

2
00:00:06,360 --> 00:00:10,860
abbiamo visto quanto è stato facile per noi configurare e quindi

3
00:00:10,860 --> 00:00:15,950
impalcatura un server destinatario utilizzando il framework LoopBack.

4
00:00:15,950 --> 00:00:20,895
Vediamo che questo framework LoopBack supporta un intero spettro

5
00:00:20,895 --> 00:00:23,040
degli endpoint destinatario e

6
00:00:23,040 --> 00:00:26,324
tutte le operazioni degli endpoint destinatario automaticamente per noi,

7
00:00:26,324 --> 00:00:28,590
quando abbiamo impalcato la nostra applicazione.

8
00:00:28,590 --> 00:00:31,755
In questo esercizio, vedremo come possiamo collegare il

9
00:00:31,755 --> 00:00:35,800
nostro server LoopBack a un database back-end,

10
00:00:35,800 --> 00:00:38,926
o MongoDB in questo caso,

11
00:00:38,926 --> 00:00:45,565
e vedremo anche come possiamo impostare vari controlli di accesso sugli endpoint destinatario.

12
00:00:45,565 --> 00:00:47,575
Quindi, utilizzando i controlli di accesso,

13
00:00:47,575 --> 00:00:52,010
possiamo specificare che tipo di operazioni possono essere eseguite sugli endpoint del destinatario

14
00:00:52,010 --> 00:00:56,730
e chi sarà autorizzato a eseguire tali operazioni.

15
00:00:56,730 --> 00:01:02,385
Ad esempio, un utente non autenticato o un ospite può

16
00:01:02,385 --> 00:01:08,666
accedere solo alle informazioni o eseguire un'operazione get sugli endpoint del destinatario,

17
00:01:08,666 --> 00:01:13,484
un utente autenticato sarebbe in grado di fare lo stesso,

18
00:01:13,484 --> 00:01:21,240
ma solo un amministratore sarebbe in grado di scrivere dati nel mio server.

19
00:01:21,240 --> 00:01:27,025
Quindi, qualsiasi operazione put, post ed delete può essere eseguita solo da un amministratore.

20
00:01:27,025 --> 00:01:32,535
Lungo la strada vedremo anche come possiamo impostare un account admin nel nostro server LoopBack,

21
00:01:32,535 --> 00:01:35,250
e quindi configurarlo in modo che

22
00:01:35,250 --> 00:01:38,880
solo l'utente amministratore sarà autorizzato a eseguire queste operazioni.

23
00:01:38,880 --> 00:01:42,246
Quindi questo è dove LoopBack ci permette di definire qualcosa

24
00:01:42,246 --> 00:01:46,080
chiamato ruoli associati a vari utenti.

25
00:01:46,080 --> 00:01:48,645
In questo modo a ciascun utente può essere assegnato un ruolo.

26
00:01:48,645 --> 00:01:52,170
Ad esempio, puoi parlare di un utente ordinario,

27
00:01:52,170 --> 00:01:55,915
un amministratore, un super amministratore e così via.

28
00:01:55,915 --> 00:02:00,675
In questo modo è possibile suddividere il set di utenti in vari gruppi

29
00:02:00,675 --> 00:02:03,793
e quindi assegnare loro vari ruoli.

30
00:02:03,793 --> 00:02:09,885
Inoltre vedremo come il modello utente incorporato può essere ulteriormente personalizzato,

31
00:02:09,885 --> 00:02:11,790
all'interno della nostra applicazione LoopBack,

32
00:02:11,790 --> 00:02:16,290
e come possiamo costruire un altro modello in cima al modello utente,

33
00:02:16,290 --> 00:02:19,710
e quindi utilizzare il modello utente come classe base

34
00:02:19,710 --> 00:02:23,400
e sviluppare un modello di livello superiore chiamato il modello cliente,

35
00:02:23,400 --> 00:02:27,060
che ci permette di memorizzare informazioni aggiuntive per ciascuno

36
00:02:27,060 --> 00:02:30,999
dei clienti che accederanno al nostro sito.

37
00:02:30,999 --> 00:02:38,040
Quindi, esploriamo alcune di queste funzionalità di LoopBack in questo esercizio.

38
00:02:38,040 --> 00:02:40,830
Per iniziare a questo esercizio,

39
00:02:40,830 --> 00:02:42,645
la prima cosa che vorrei che tu facessi,

40
00:02:42,645 --> 00:02:44,040
è avviare il tuo server MongoDB.

41
00:02:44,040 --> 00:02:49,545
Quindi eccomi qui in un'altra scheda terminale nella mia cartella MongoDB,

42
00:02:49,545 --> 00:02:52,950
dove ho configurato il mio server MongoDB in precedenza,

43
00:02:52,950 --> 00:02:59,065
che è stato utilizzato dal mio server Express Plus MongoDB negli esercizi precedenti.

44
00:02:59,065 --> 00:03:03,775
Quindi lasciami avviare il server MongoDB digitando

45
00:03:03,775 --> 00:03:11,190
MonGod meno i dati della parte D-B

46
00:03:11,190 --> 00:03:15,334
in questa cartella e quindi avviare il mio server MongoDB.

47
00:03:15,334 --> 00:03:20,005
Ora, ho intenzione di collegare il mio server LoopBack al mio server MongoDB.

48
00:03:20,005 --> 00:03:23,920
Quindi andando nella mia cartella del server LoopBack qui,

49
00:03:23,920 --> 00:03:28,560
devo richiedere il tipo di origine dati L-B.

50
00:03:28,560 --> 00:03:32,820
Questo ci permetterà di configurare l'origine dati per il nostro server LoopBack.

51
00:03:32,820 --> 00:03:39,460
LoopBack stesso può connettersi contemporaneamente a più origini dati se

52
00:03:39,460 --> 00:03:41,843
lo si sceglie, e supporta vari tipi.

53
00:03:41,843 --> 00:03:46,800
Supporta database My Cycle, supporta MongoDB,

54
00:03:46,800 --> 00:03:52,175
supporta Cloudant che è anche un altro database di documenti,

55
00:03:52,175 --> 00:03:58,410
supporta Oracle e molti altri tipi di database.

56
00:03:58,410 --> 00:04:01,830
Quindi, puoi facilmente configurarlo.

57
00:04:01,830 --> 00:04:04,620
In questo esempio, ho intenzione di configurare il mio server LoopBack

58
00:04:04,620 --> 00:04:07,810
per parlare con il mio MongoDB nel back-end.

59
00:04:07,810 --> 00:04:09,445
Quindi, al prompt,

60
00:04:09,445 --> 00:04:11,590
se digitiamo L-B origine dati,

61
00:04:11,590 --> 00:04:14,610
ci chiederà informazioni.

62
00:04:14,610 --> 00:04:18,155
Quindi la prima cosa che ci chiederà è il nome dell'origine dati,

63
00:04:18,155 --> 00:04:24,570
e quindi configurerò questo nome dell'origine dati come MongoDB,

64
00:04:24,570 --> 00:04:29,315
e quindi mi chiederà di selezionare il connettore.

65
00:04:29,315 --> 00:04:36,120
LoopBack utilizza connettori per connettersi a vari database dietro le quinte.

66
00:04:36,120 --> 00:04:38,790
Quindi, come puoi vedere, il DB in memoria che è quello che

67
00:04:38,790 --> 00:04:41,795
hanno appena usato nell'esercizio precedente,

68
00:04:41,795 --> 00:04:45,105
ma ovviamente il DB in memoria significa che una volta arrestato il server,

69
00:04:45,105 --> 00:04:47,220
tutti i valori saranno spariti,

70
00:04:47,220 --> 00:04:51,080
e quindi non è una memorizzazione di dati persistente.

71
00:04:51,080 --> 00:04:58,440
Quindi qui vedete i vari tipi di database che StrongLoop supporta qui.

72
00:04:58,440 --> 00:05:06,720
Così si può vedere la lunga lista dei vari database che sono supportati.

73
00:05:06,720 --> 00:05:09,280
Quindi puoi vedere che supporta Cassandra, Redis,

74
00:05:09,280 --> 00:05:15,360
avevamo brevemente fatto riferimento a questi quando abbiamo parlato di database NoSQL, MongoDB,

75
00:05:15,360 --> 00:05:18,385
My SQL, PostGres, Oracle

76
00:05:18,385 --> 00:05:24,325
e anche direttamente ad altri server API Rest ai server SOAP,

77
00:05:24,325 --> 00:05:26,865
Coachbase e così via.

78
00:05:26,865 --> 00:05:29,040
Quindi vedete che ci fornisce

79
00:05:29,040 --> 00:05:33,450
una lunga lista di vari tipi di fonti di dati da lì,

80
00:05:33,450 --> 00:05:36,783
il nostro server LoopBack può leggere nelle informazioni.

81
00:05:36,783 --> 00:05:39,835
Nel mio caso, ho intenzione di utilizzare il server MongoDB, quindi ho

82
00:05:39,835 --> 00:05:43,170
intenzione di impostare il connettore MongoDB.

83
00:05:43,170 --> 00:05:44,660
Quindi, quando lo faccio,

84
00:05:44,660 --> 00:05:50,775
LoopBack installerà automaticamente il connettore MongoDB per noi,

85
00:05:50,775 --> 00:05:57,810
e quando chiede l'URL della stringa di connessione,

86
00:05:57,810 --> 00:06:01,570
lo lasceremo vuoto perché gli permetteremo di utilizzare il modo standard di configurazione.

87
00:06:01,570 --> 00:06:04,550
Quando chiede l'host diremo

88
00:06:04,550 --> 00:06:09,815
localhost perché stiamo eseguendo il nostro MongoDB sullo stesso computer.

89
00:06:09,815 --> 00:06:11,260
In caso contrario, si specifica

90
00:06:11,260 --> 00:06:16,275
il nome host del computer su cui si è in esecuzione MongoDB.

91
00:06:16,275 --> 00:06:20,080
Poi il prossimo è il numero di porta e stiamo

92
00:06:20,080 --> 00:06:24,665
usando il nostro numero di porta standard MongoDB 27017,

93
00:06:24,665 --> 00:06:29,186
e chiederà anche il nome utente e la password se richiesto,

94
00:06:29,186 --> 00:06:32,770
e in questo momento il mio MongoDB è in esecuzione senza dover

95
00:06:32,770 --> 00:06:36,850
fare alcuna autenticazione, quindi lascio il nome utente e la password vuoti,

96
00:06:36,850 --> 00:06:38,575
e il nome del database.

97
00:06:38,575 --> 00:06:44,490
Il nome del database sul server MongoDB che è in esecuzione dietro le quinte,

98
00:06:44,490 --> 00:06:47,390
il nome del database c'è confusione.

99
00:06:47,390 --> 00:06:52,040
Se ricordi che è il nome del database che hanno impostato sul nostro server MongoDB.

100
00:06:52,040 --> 00:06:56,900
E poi ci chiederà se dovrebbe installare il connettore LoopBack,

101
00:06:56,900 --> 00:06:58,750
e dirò di sì,

102
00:06:58,750 --> 00:07:02,410
e in realtà andrà avanti e installare il modulo NPM che accede

103
00:07:02,410 --> 00:07:07,715
al connettore LoopBack al database MongoDB.

104
00:07:07,715 --> 00:07:09,415
E una volta fatto,

105
00:07:09,415 --> 00:07:14,630
il mio connettore Loopback è installato qui in modo da poter vedere che questa è la versione 1.18.1

106
00:07:14,630 --> 00:07:19,910
e il mio server LoopBack è tutto pronto per parlare con il mio MongoDB.

107
00:07:19,910 --> 00:07:22,615
Ora, prima di procedere

108
00:07:22,615 --> 00:07:26,090
in avanti, nell'esercizio precedente non configuro davvero alcuni modelli

109
00:07:26,090 --> 00:07:30,115
e quindi li specifico da archiviare nel DB,

110
00:07:30,115 --> 00:07:35,295
dovrò andare e aggiornarli per memorizzare i loro dati nel mio MongoDB.

111
00:07:35,295 --> 00:07:41,610
Quindi, andiamo e reimpostiamo rapidamente il nostro codice per il server LoopBack.

112
00:07:41,610 --> 00:07:44,770
Questo ci offre anche l'opportunità di esaminare

113
00:07:44,770 --> 00:07:49,030
ciò che il mio server Loopback stesso ha configurato in questa cartella.

114
00:07:49,030 --> 00:07:54,730
Aprendo la cartella LoopBack nel nostro editor,

115
00:07:54,730 --> 00:07:58,200
puoi vedere che Loopback ha già

116
00:07:58,200 --> 00:08:02,000
impalcato un sacco di file in questa cartella.

117
00:08:02,000 --> 00:08:04,080
Il package.json naturalmente contiene

118
00:08:04,080 --> 00:08:10,275
tutti i relativi moduli NPM che sono stati configurati qui fuori,

119
00:08:10,275 --> 00:08:17,901
e qui dentro puoi vedere che LoopBack stesso ha configurato il modulo NPM di LoopBack,

120
00:08:17,901 --> 00:08:20,970
il modulo di avvio LoopBack e in

121
00:08:20,970 --> 00:08:24,840
particolare lasciatemi attirare la vostra attenzione sul loopBack MongoDB ,

122
00:08:24,840 --> 00:08:32,055
che avevamo appena installato poco fa, e molti altri.

123
00:08:32,055 --> 00:08:36,150
In particolare la configurazione per il server Loopback è tutta

124
00:08:36,150 --> 00:08:40,075
memorizzata principalmente nei file Json qui,

125
00:08:40,075 --> 00:08:44,970
con javascriptcore aggiuntivo ogni volta che richiesto.

126
00:08:44,970 --> 00:08:50,670
Cercheremo la personalizzazione del codice javascript un po 'più tardi.

127
00:08:50,670 --> 00:08:53,875
Permettetemi di attirare la vostra attenzione su questa cartella chiamata comune.

128
00:08:53,875 --> 00:08:55,850
In questa cartella comune,

129
00:08:55,850 --> 00:09:01,725
vedrai tutti i modelli che abbiamo configurato in precedenza.

130
00:09:01,725 --> 00:09:04,860
Quindi vedrai che abbiamo i file Dishes.json.

131
00:09:04,860 --> 00:09:09,210
Quindi, quando apri il file dishes.json, vedi come LoopBack

132
00:09:09,210 --> 00:09:14,695
memorizza tutte le informazioni sul modello di piatti che hai appena creato,

133
00:09:14,695 --> 00:09:17,790
quindi ha il nome, la base

134
00:09:17,790 --> 00:09:21,655
e alcuni altri valori qui che richiede.

135
00:09:21,655 --> 00:09:27,369
E poi guarda le proprietà e come tutte le proprietà sono memorizzate qui.

136
00:09:27,369 --> 00:09:30,735
Quindi vedi alcune cose che sono molto facili da

137
00:09:30,735 --> 00:09:34,790
riconoscere che sono nel file dishes.json.

138
00:09:34,790 --> 00:09:39,040
Allo stesso modo, i leaders.json e le promotions.json.

139
00:09:39,040 --> 00:09:42,171
Il file dishes.js è grande,

140
00:09:42,171 --> 00:09:46,007
possiamo aggiungere un codice di personalizzazione aggiuntivo per i piatti,

141
00:09:46,007 --> 00:09:48,050
ma in questo momento non lo faremo,

142
00:09:48,050 --> 00:09:50,755
e quindi lo lasceremo così com'è.

143
00:09:50,755 --> 00:09:56,130
Quindi questo è dove è possibile aggiungere un codice aggiuntivo che potrebbe

144
00:09:56,130 --> 00:10:02,610
essere necessario eseguire quando si accede al punto finale dei piatti della barra.

145
00:10:02,610 --> 00:10:07,630
Ma adesso lo lasceremo vuoto per il momento.

146
00:10:07,630 --> 00:10:11,725
Ora diamo un'occhiata anche alla cartella del server qui.

147
00:10:11,725 --> 00:10:13,465
E la cartella del server,

148
00:10:13,465 --> 00:10:18,745
in particolare lasciatemi attirare la vostra attenzione sul file datasources.json qui.

149
00:10:18,745 --> 00:10:20,996
Nel file sources.json,

150
00:10:20,996 --> 00:10:23,740
tutte le diverse origini dati verranno configurate qui.

151
00:10:23,740 --> 00:10:26,470
Quindi in questo momento, abbiamo solo il DB che è

152
00:10:26,470 --> 00:10:31,634
il database DB in memoria che LoopBack per impostazione predefinita configura,

153
00:10:31,634 --> 00:10:34,045
e quindi il MongoDB che abbiamo appena configurato,

154
00:10:34,045 --> 00:10:36,700
assorbito solo le informazioni che l'input

155
00:10:36,700 --> 00:10:40,570
è stato memorizzato in quelle origini dati, file json.

156
00:10:40,570 --> 00:10:46,880
Quindi, vedrai che LoopBack stesso funziona configurando tutti questi file

157
00:10:46,880 --> 00:10:50,493
che il framework LoopBack stesso fa uso di quando

158
00:10:50,493 --> 00:10:56,332
avvia il server API di riposo basato su Loopback.

159
00:10:56,332 --> 00:11:00,620
Andiamo nel file config.json modello qui.

160
00:11:00,620 --> 00:11:03,050
Il file config.json modello stesso

161
00:11:03,050 --> 00:11:09,028
memorizza molte informazioni qui che sono utili per noi,

162
00:11:09,028 --> 00:11:13,810
ma qui, entriamo e modifichiamo alcune cose.

163
00:11:13,810 --> 00:11:20,500
Quindi, in questo, vedremo che ci sono di nuovo per i piatti,

164
00:11:20,500 --> 00:11:24,965
promozioni e leader, l'origine dati è stato configurato come DB.

165
00:11:24,965 --> 00:11:32,150
Quindi lo modificheremo a MongoDB qui.

166
00:11:32,150 --> 00:11:34,700
Non solo per questo,

167
00:11:34,700 --> 00:11:39,053
cambieranno anche quello per le promozioni, e anche i leader

168
00:11:39,053 --> 00:11:45,590
, il che significa che tutti e tre trarranno i loro dati dal MongoDB.

169
00:11:45,590 --> 00:11:48,720
Inoltre, per il ruolo definito qui.

170
00:11:48,720 --> 00:11:50,170
Conserveremo anche a MongoDB.

171
00:11:50,170 --> 00:11:53,635
Vedremo molto presto come faremo uso del ruolo,

172
00:11:53,635 --> 00:11:56,290
e anche il RoleMapping qui.

173
00:11:56,290 --> 00:12:00,675
Capiremo il motivo di questi due tra poco.

174
00:12:00,675 --> 00:12:04,030
E poi, ACL, gli elenchi di controllo di accesso,

175
00:12:04,030 --> 00:12:07,740
questi saranno anche memorizzati in MongoDB.

176
00:12:07,740 --> 00:12:10,210
E poi, l'utente, anche,

177
00:12:10,210 --> 00:12:12,105
lo memorizzeremo in MongoDB,

178
00:12:12,105 --> 00:12:13,848
e poi lo lasceranno lì.

179
00:12:13,848 --> 00:12:17,175
Quindi, queste sono le modifiche che dovresti fare

180
00:12:17,175 --> 00:12:23,744
al file model-config.json e quindi salvare le modifiche.

181
00:12:23,744 --> 00:12:27,239
Come ho accennato in precedenza, Loopback per impostazione predefinita,

182
00:12:27,239 --> 00:12:29,705
supporta questo modello chiamato, utente,

183
00:12:29,705 --> 00:12:33,215
che viene utilizzato per supportare l'autenticazione utente.

184
00:12:33,215 --> 00:12:36,890
Il modello utente stesso memorizza solo tre proprietà diverse.

185
00:12:36,890 --> 00:12:40,100
Il nome utente, l'indirizzo e-mail

186
00:12:40,100 --> 00:12:42,890
e le informazioni relative alla password.

187
00:12:42,890 --> 00:12:44,060
Ora, se vogliono avere

188
00:12:44,060 --> 00:12:49,125
un modo più elaborato di memorizzare informazioni aggiuntive sugli utenti.

189
00:12:49,125 --> 00:12:54,200
Quindi possono sottoclasse questo modello di base utente

190
00:12:54,200 --> 00:12:56,180
e quindi farne uso.

191
00:12:56,180 --> 00:12:57,950
Quindi, in questo passaggio successivo,

192
00:12:57,950 --> 00:13:01,880
creerò un altro modello chiamato, il modello cliente,

193
00:13:01,880 --> 00:13:08,490
che utilizzerà l'utente come modello di base per il suo funzionamento.

194
00:13:08,490 --> 00:13:13,005
E il modello cliente stesso memorizzerà ulteriori informazioni sugli utenti.

195
00:13:13,005 --> 00:13:14,255
Quindi, nel modello cliente,

196
00:13:14,255 --> 00:13:16,820
memorizzerò le cose come il nome,

197
00:13:16,820 --> 00:13:20,900
il cognome e l'immagine per l'utente e così via.

198
00:13:20,900 --> 00:13:24,035
Quindi, il cliente agirà esattamente come il modello utente,

199
00:13:24,035 --> 00:13:29,889
che già viene fornito con il proprio set di metodi.

200
00:13:29,889 --> 00:13:32,780
E così il modello utente viene utilizzato per l'autenticazione utente,

201
00:13:32,780 --> 00:13:34,700
in modo da poter digitare il nome utente e la password,

202
00:13:34,700 --> 00:13:35,930
e accedere e disconnettersi.

203
00:13:35,930 --> 00:13:41,850
Pertanto, quando abbiamo creato questo modello cliente in base alla classe base del modello utente,

204
00:13:41,850 --> 00:13:44,742
il modello cliente supporterà anche le

205
00:13:44,742 --> 00:13:47,680
operazioni di accesso e disconnessione nell'utilizzo di questo modello cliente.

206
00:13:47,680 --> 00:13:51,880
Quindi, possiamo accedere all'utente e disconnettere l'utente e così via.

207
00:13:51,880 --> 00:13:56,520
Quindi, l'autenticazione utente arriva automaticamente per il diritto.

208
00:13:56,520 --> 00:13:59,750
Quindi, per creare il modello cliente, al prompt,

209
00:13:59,750 --> 00:14:03,340
digitare modello lb e per il nome del modello,

210
00:14:03,340 --> 00:14:06,440
digiteremo Cliente.

211
00:14:06,440 --> 00:14:10,700
E il DataSource, lo sceglierò come MongoDB.

212
00:14:10,700 --> 00:14:15,080
E poi quando chiede di selezionare la classe base del modello,

213
00:14:15,080 --> 00:14:17,435
invece di utilizzare il PersistedModel,

214
00:14:17,435 --> 00:14:18,875
ci sposteremo verso il basso,

215
00:14:18,875 --> 00:14:23,570
e quindi selezionare l'utente come classe base.

216
00:14:23,570 --> 00:14:27,215
Quindi, in questo modo, deriverà tutte le loro proprietà

217
00:14:27,215 --> 00:14:31,275
della classe utente di base già incorporata in Loopback.

218
00:14:31,275 --> 00:14:35,370
E poi esporremo questo con l'API REST

219
00:14:35,370 --> 00:14:39,353
e il MT plurale personalizzato.

220
00:14:39,353 --> 00:14:42,765
E poi questo sarebbe nella cartella comune.

221
00:14:42,765 --> 00:14:49,081
E per questo, le tre proprietà che aggiungeremo sono,

222
00:14:49,081 --> 00:14:54,900
nome, che avremmo la stringa tipi.

223
00:14:54,900 --> 00:14:58,700
E questo non è obbligatorio o non ha un valore predefinito.

224
00:14:58,700 --> 00:15:05,895
E poi, cognome di nuovo come stringa di tipo,

225
00:15:05,895 --> 00:15:08,825
non obbligatorio, e nessun valore predefinito.

226
00:15:08,825 --> 00:15:11,860
E poi immagine della stringa di tipo,

227
00:15:11,860 --> 00:15:15,249
non richiesta e nessun valore predefinito.

228
00:15:15,249 --> 00:15:18,095
Quindi, si vede che la classe cliente stessa

229
00:15:18,095 --> 00:15:22,546
porta proprietà aggiuntive oltre alla classe utente.

230
00:15:22,546 --> 00:15:25,006
la classe utente supporta già il nome utente,

231
00:15:25,006 --> 00:15:28,465
l'e-mail e le informazioni relative alla password.

232
00:15:28,465 --> 00:15:30,185
Quindi, la classe cliente,

233
00:15:30,185 --> 00:15:32,030
dal momento che la sottoclasse è la classe base,

234
00:15:32,030 --> 00:15:38,405
otterremo il nome utente e l'e-mail automaticamente dalla classe utente.

235
00:15:38,405 --> 00:15:41,870
E ora, quando vai al file model-config.jason,

236
00:15:41,870 --> 00:15:46,725
vedrai che il modello Customer è già stato aggiunto lì.

237
00:15:46,725 --> 00:15:48,390
E poi nei modelli comuni,

238
00:15:48,390 --> 00:15:51,278
vedrai ora il file customer.json aggiunto lì

239
00:15:51,278 --> 00:15:55,365
con queste tre proprietà aggiuntive che abbiamo aggiunto al modello cliente.

240
00:15:55,365 --> 00:16:02,020
Ma nota, che specifica la base come classe utente per il modello cliente qui.

241
00:16:02,020 --> 00:16:04,760
Quindi, è così che Loopback ti consente di prendere

242
00:16:04,760 --> 00:16:09,832
una classe del modello di base e quindi sottoclasse quella nella classe del modello.

243
00:16:09,832 --> 00:16:16,340
Quindi, vedrai come Loopback ci consente di supportare automaticamente l'autenticazione utente utilizzando

244
00:16:16,340 --> 00:16:23,855
la classe utente e quindi ci permette di definire anche sottoclasse aggiuntiva di quello,

245
00:16:23,855 --> 00:16:29,780
che memorizzerà ulteriori informazioni relative alla classe di base utente.

246
00:16:29,780 --> 00:16:32,660
Successivamente, imposteremo il controllo degli

247
00:16:32,660 --> 00:16:38,210
accessi per i vari modelli che abbiamo già impostato nel nostro server Loopback.

248
00:16:38,210 --> 00:16:40,190
Quindi, per impostare il controllo di accesso

249
00:16:40,190 --> 00:16:45,170
o gli elenchi di controllo di accesso in Lookback.

250
00:16:45,170 --> 00:16:49,730
Loopback utilizza questi elenchi di controllo di accesso come un modo per specificare il tipo di

251
00:16:49,730 --> 00:16:51,290
operazioni che possono essere eseguite

252
00:16:51,290 --> 00:16:55,280
sui diversi endpoint API REST sono corrispondenti con i diversi modelli.

253
00:16:55,280 --> 00:16:58,695
Quindi, per farlo, digiteremo al prompt lb acl,

254
00:16:58,695 --> 00:17:01,880
ACL sta per Access Control List.

255
00:17:01,880 --> 00:17:06,980
E poi, quando questo si esaurisce, diremo, a

256
00:17:06,980 --> 00:17:11,960
quale modello vogliamo applicare questa lista di controllo di accesso.

257
00:17:11,960 --> 00:17:14,678
E poi diremo, tutti i modelli esistenti.

258
00:17:14,678 --> 00:17:18,845
E diremo, Tutte le metriche e le proprietà.

259
00:17:18,845 --> 00:17:20,810
E diremo,

260
00:17:20,810 --> 00:17:23,233
Tutti i tipi di operazioni.

261
00:17:23,233 --> 00:17:25,910
E poi, diremo, Tutti gli utenti.

262
00:17:25,910 --> 00:17:28,730
E poi diremo, negare esplicitamente l'accesso.

263
00:17:28,730 --> 00:17:32,976
Quindi, stiamo prima chiudendo tutti i modelli per tutto,

264
00:17:32,976 --> 00:17:34,670
poi ci apriremo lentamente,

265
00:17:34,670 --> 00:17:38,270
indipendentemente dalle operazioni che possono essere eseguite da utenti diversi.

266
00:17:38,270 --> 00:17:40,385
Quindi, primo passo, abbiamo chiuso

267
00:17:40,385 --> 00:17:45,715
tutti i tipi di operazioni su tutti i modelli che abbiamo attualmente.

268
00:17:45,715 --> 00:17:51,740
Quindi, inizieremo lentamente ad aprire ogni operazione, passo dopo passo.

269
00:17:51,740 --> 00:17:53,300
Ora, il passo successivo,

270
00:17:53,300 --> 00:17:59,960
quello che faremo è di nuovo impostare la prossima lista di controllo di accesso.

271
00:17:59,960 --> 00:18:02,525
Nella seconda lista di controllo di accesso, diremo,

272
00:18:02,525 --> 00:18:06,095
per tutti i modelli esistenti e diremo,

273
00:18:06,095 --> 00:18:08,930
Tutte le metriche e le proprietà.

274
00:18:08,930 --> 00:18:13,400
E poi, diremo, solo accesso in lettura.

275
00:18:13,400 --> 00:18:18,416
Significato, quando l'utente può eseguire le operazioni GET su queste porte finali.

276
00:18:18,416 --> 00:18:24,680
E queste operazioni GET possono essere eseguite da tutti gli utenti.

277
00:18:24,680 --> 00:18:27,805
Quindi, gli utenti possono recuperare informazioni.

278
00:18:27,805 --> 00:18:31,605
E concederemo esplicitamente l'accesso per questo.

279
00:18:31,605 --> 00:18:35,804
Quindi, il che significa che le operazioni GET sono consentite sul nodo endpoint API REST.

280
00:18:35,804 --> 00:18:37,610
Innanzitutto, abbiamo chiuso tutto,

281
00:18:37,610 --> 00:18:40,880
quindi abbiamo aperto solo le operazioni GET per gli utenti.

282
00:18:40,880 --> 00:18:46,175
Ora, infine, andranno a ciascuno dei modelli,

283
00:18:46,175 --> 00:18:49,490
quindi chiuderanno e consentiranno di

284
00:18:49,490 --> 00:18:53,068
eseguire determinate operazioni solo da determinati tipi di utenti.

285
00:18:53,068 --> 00:18:54,625
Quindi, per farlo,

286
00:18:54,625 --> 00:19:00,511
il prossimo ACL che imposteremo è per un modello specifico.

287
00:19:00,511 --> 00:19:03,197
Quindi prepareremo questo per i piatti.

288
00:19:03,197 --> 00:19:06,445
E diremo, Un singolo metodo.

289
00:19:06,445 --> 00:19:08,685
E poi il nome del metodo è, crea.

290
00:19:08,685 --> 00:19:13,320
Quindi, il che significa che la creazione di questi sarà consentita solo da.

291
00:19:13,320 --> 00:19:15,850
Quindi, ancora una volta, quando si dice selezionare il ruolo,

292
00:19:15,850 --> 00:19:18,260
quindi per il ruolo, diremo, altro.

293
00:19:18,260 --> 00:19:20,530
E poi il nome del ruolo sarebbe admin.

294
00:19:20,530 --> 00:19:24,663
Quindi, quello che stiamo facendo con questa operazione è che,

295
00:19:24,663 --> 00:19:32,755
stiamo dicendo che solo un utente amministratore può creare nuovi piatti o aggiornare piatti esistenti.

296
00:19:32,755 --> 00:19:38,535
Quindi, questo è un po 'vicino, le operazioni rimanenti.

297
00:19:38,535 --> 00:19:45,669
Quindi, facciamo la stessa cosa per i leader.

298
00:19:45,669 --> 00:19:48,880
E un singolo metodo e poi,

299
00:19:48,880 --> 00:19:53,821
il creare e diremo,

300
00:19:53,821 --> 00:19:58,320
solo l'amministratore può farlo.

301
00:19:58,320 --> 00:20:04,330
E poi finalmente, anche per le promozioni.

302
00:20:04,330 --> 00:20:05,919
Per le promozioni.

303
00:20:05,919 --> 00:20:10,210
Il metodo singolo, il metodo create, sarà consentito

304
00:20:10,210 --> 00:20:15,415
solo dagli utenti che hanno il ruolo designato come amministratore.

305
00:20:15,415 --> 00:20:20,340
Vedremo come creeremo utenti con un ruolo specifico nel passaggio successivo.

306
00:20:20,340 --> 00:20:22,398
Concedere esplicitamente l'accesso.

307
00:20:22,398 --> 00:20:26,995
Ora si noti che non ho chiuso i clienti per le operazioni di creazione.

308
00:20:26,995 --> 00:20:28,305
Se chiudo i clienti,

309
00:20:28,305 --> 00:20:31,383
nessuno potrà registrarsi nel sistema.

310
00:20:31,383 --> 00:20:33,220
Quindi, e' per questo che lascio aperto.

311
00:20:33,220 --> 00:20:37,170
Perché, il cliente dovrebbe essere in grado di registrarsi nel sistema.

312
00:20:37,170 --> 00:20:41,364
Quindi, puoi registrarti per nuovi account sul sistema.

313
00:20:41,364 --> 00:20:42,420
Account utente sul sistema.

314
00:20:42,420 --> 00:20:45,585
Quindi, questo sarà lasciato aperto alle persone.

315
00:20:45,585 --> 00:20:50,800
Quindi, per consentire che per i clienti, diremo, clienti,

316
00:20:50,800 --> 00:20:59,880
Un unico metodo, creare tutti gli utenti.

317
00:20:59,880 --> 00:21:03,450
Pertanto, i clienti possono essere creati da tutti gli utenti perché ciò

318
00:21:03,450 --> 00:21:07,125
consentirà alle persone di accedere al proprio account.

319
00:21:07,125 --> 00:21:11,820
Infine, vedremo come possiamo configurare il nostro server per avviare

320
00:21:11,820 --> 00:21:17,590
con un singolo utente amministratore automatico configurato nel nostro server Loopback.

321
00:21:17,590 --> 00:21:19,300
Quindi, per farlo,

322
00:21:19,300 --> 00:21:20,820
nel nostro server Loopback,

323
00:21:20,820 --> 00:21:25,015
nella cartella server abbiamo questa sottocartella di avvio qui.

324
00:21:25,015 --> 00:21:28,380
Qualunque sia il codice che abbiamo inserito nella sottocartella di avvio,

325
00:21:28,380 --> 00:21:33,385
verrà eseguito all'avvio del nostro server LoopBack.

326
00:21:33,385 --> 00:21:37,253
Quindi, qui, vedrai che abbiamo già questo authentication.js,

327
00:21:37,253 --> 00:21:38,490
che è già impostato,

328
00:21:38,490 --> 00:21:42,255
un Loopback che imposterà l'autenticazione utente per noi.

329
00:21:42,255 --> 00:21:44,790
E poi abbiamo il root.js che imposterà

330
00:21:44,790 --> 00:21:49,650
alcune informazioni aggiuntive per il nostro server RAM Loopback.

331
00:21:49,650 --> 00:21:52,920
E possiamo aggiungere altri file qui.

332
00:21:52,920 --> 00:21:55,696
Quindi, ho intenzione di andare lì nella cartella di avvio,

333
00:21:55,696 --> 00:22:01,111
e quindi aggiungere questo file chiamato, script.js.

334
00:22:01,111 --> 00:22:03,259
E in questo script.js,

335
00:22:03,259 --> 00:22:07,610
ho intenzione di impostare il codice per creare un utente amministratore per impostazione predefinita.

336
00:22:07,610 --> 00:22:08,785
Quindi, nel script.js,

337
00:22:08,785 --> 00:22:12,335
che non sarà altro che un modulo NPM basato su file, quindi,

338
00:22:12,335 --> 00:22:13,995
ci avvieremo dicendo,

339
00:22:13,995 --> 00:22:21,050
module.exports = function (app).

340
00:22:21,050 --> 00:22:23,355
L' app è l'app Loopback,

341
00:22:23,355 --> 00:22:28,185
che verrà fornita come parametro per questa funzione per noi.

342
00:22:28,185 --> 00:22:32,072
E così, possiamo farne uso all'interno del nostro codice qui.

343
00:22:32,072 --> 00:22:39,585
Quindi, qui dentro, per prima cosa imposteremo un utente amministratore.

344
00:22:39,585 --> 00:22:41,003
Quindi, per fare questo, diremo,

345
00:22:41,003 --> 00:22:51,840
var Cliente = app.models.Customer.

346
00:22:51,840 --> 00:22:56,580
Quindi, questo ci dà accesso al modello cliente.

347
00:22:56,580 --> 00:23:03,321
Allora diremo, clienti.Findone.

348
00:23:03,321 --> 00:23:08,820
Quindi, prima controlleremo per vedere se un utente con

349
00:23:08,820 --> 00:23:16,920
il nome utente come amministratore è già configurato nel sistema o meno.

350
00:23:16,920 --> 00:23:20,585
In caso contrario, creerò un utente amministratore.

351
00:23:20,585 --> 00:23:30,230
E questo mi fornisce una funzione di callback con due parametri, err e utenti.

352
00:23:30,230 --> 00:23:34,470
E all'interno di questo- Quindi cercheremo prima di

353
00:23:34,470 --> 00:23:39,195
vedere se un utente con il loro nome admin esiste già.

354
00:23:39,195 --> 00:23:40,800
Se l'utente non esiste

355
00:23:40,800 --> 00:23:42,453
, creeremo l'utente.

356
00:23:42,453 --> 00:23:43,800
Quindi, per creare l'utente,

357
00:23:43,800 --> 00:23:49,326
diremo qui, se non gli utenti.

358
00:23:49,326 --> 00:23:55,830
Quindi, se gli utenti non sono nulli o se l'utente dice null,

359
00:23:55,830 --> 00:24:02,305
ciò significa che non esiste un utente amministratore, quindi ho bisogno di creare un utente amministratore qui.

360
00:24:02,305 --> 00:24:09,330
Quindi, in questo caso, diremo, cliente.create.

361
00:24:09,330 --> 00:24:19,835
E questa creazione richiede una serie di oggetti, se vuoi.

362
00:24:19,835 --> 00:24:30,235
E questa matrice di oggetti ci permetterà di specificare quali account utente vogliamo creare.

363
00:24:30,235 --> 00:24:33,575
Quindi il primo account utente che voglio creare o

364
00:24:33,575 --> 00:24:38,678
l'unico account utente che voglio creare è «Amministratore».

365
00:24:38,678 --> 00:24:41,845
Quindi questo sarà l'amministratore predefinito per

366
00:24:41,845 --> 00:24:47,447
il mio server di loopback e quindi posso configurare l'e-mail.

367
00:24:47,447 --> 00:24:56,850
Quindi ricorda che il modello utente supporta queste proprietà,

368
00:24:56,850 --> 00:25:02,380
confusion.net e quindi password

369
00:25:02,380 --> 00:25:07,253
che configurerò come password.

370
00:25:07,253 --> 00:25:09,790
È anche possibile fornire insieme a questo,

371
00:25:09,790 --> 00:25:11,560
il nome e il cognome,

372
00:25:11,560 --> 00:25:14,345
se si desidera, per l'utente amministratore.

373
00:25:14,345 --> 00:25:16,975
Ma ho intenzione di lasciarlo come tale,

374
00:25:16,975 --> 00:25:20,640
come vuoto perché quelli non sono richiesti per l'utente admin.

375
00:25:20,640 --> 00:25:22,270
Quindi lo lascio lì.

376
00:25:22,270 --> 00:25:28,765
Quindi questo comando finirà per creare un nuovo cliente con il nome 'Admin'.

377
00:25:28,765 --> 00:25:34,480
Quindi, se questo utente o il nome «Admin» non esiste,

378
00:25:34,480 --> 00:25:36,194
allora stiamo andando a crearne uno.

379
00:25:36,194 --> 00:25:43,800
E poi qui abbiamo la funzione di callback.

380
00:25:45,150 --> 00:25:54,240
Quindi sbagliare gli utenti.

381
00:25:54,240 --> 00:25:57,965
Ora dirò,

382
00:25:57,965 --> 00:26:06,850
se sbagliamo, non sappiamo cosa sta cercando di fare, quindi semplicemente lanciamo l'errore.

383
00:26:06,850 --> 00:26:12,210
Ma normalmente non ci aspettiamo che questo accada.

384
00:26:12,210 --> 00:26:17,650
Quindi ora, come si designa questo utente come utente amministrativo?

385
00:26:17,650 --> 00:26:19,290
Quindi in questo momento, quando mi iscrivo qui,

386
00:26:19,290 --> 00:26:21,305
sto solo registrando un utente normale qui,

387
00:26:21,305 --> 00:26:24,270
ma vogliamo dare un ruolo speciale a questo utente.

388
00:26:24,270 --> 00:26:30,775
In questo modo loopback supporta un modo di specificare i ruoli per gli utenti.

389
00:26:30,775 --> 00:26:32,775
Quindi, per specificare un ruolo,

390
00:26:32,775 --> 00:26:39,609
ci var ruolo = app.models.Role.

391
00:26:39,609 --> 00:26:42,490
Quindi questo mi permetterà di creare un ruolo,

392
00:26:42,490 --> 00:26:44,670
un nuovo ruolo chiama admin qui.

393
00:26:44,670 --> 00:26:48,600
Quindi possiamo assegnare diversi droni a utenti diversi, se vuoi.

394
00:26:48,600 --> 00:26:50,365
E insieme a questo,

395
00:26:50,365 --> 00:26:55,394
ho anche bisogno di creare un RoleMapapping qui.

396
00:26:55,394 --> 00:27:05,519
Quindi diremo, App.Models.RoleMapping.

397
00:27:05,519 --> 00:27:12,045
E se succede che il database contiene già un

398
00:27:12,045 --> 00:27:18,821
RoleMapping che esiste già,

399
00:27:18,821 --> 00:27:25,290
allora distruggerò tutti quelli quando avvio il mio server.

400
00:27:25,290 --> 00:27:35,650
E poi fammi provare

401
00:27:36,120 --> 00:27:40,550
a trovare per vedere se un ruolo con

402
00:27:40,550 --> 00:27:46,130
quel nome admin

403
00:27:46,130 --> 00:27:53,180
esiste già nel sistema.

404
00:27:53,180 --> 00:27:54,885
Ok.

405
00:27:54,885 --> 00:27:56,420
E in questo richiede,

406
00:27:56,420 --> 00:27:57,560
come ci si aspetterebbe,

407
00:27:57,560 --> 00:28:06,795
una funzione di callback e dentro qui diremo, ruolo.findone.

408
00:28:06,795 --> 00:28:10,530
Quindi se esiste già un ruolo con il nome admin,

409
00:28:10,530 --> 00:28:11,927
non ho bisogno di crearne uno.

410
00:28:11,927 --> 00:28:18,710
Altrimenti, se ciò non esiste,

411
00:28:18,710 --> 00:28:20,427
allora ho bisogno di creare il ruolo.

412
00:28:20,427 --> 00:28:29,540
Quindi diremo, ruolo.Creare.

413
00:28:29,540 --> 00:28:34,950
Quindi creeremo il ruolo di amministratore qui.

414
00:28:34,950 --> 00:28:45,230
E poi questo ci porta ai parametri err,

415
00:28:45,230 --> 00:28:52,523
ruolo qui, nella funzione di callback.

416
00:28:52,523 --> 00:28:56,215
Ora di nuovo, qui per gestire l'errore,

417
00:28:56,215 --> 00:29:03,749
copieremo questo 'if err' e poi incollarlo lì.

418
00:29:03,749 --> 00:29:06,685
Allo stesso modo anche qui, se si verifica l'errore,

419
00:29:06,685 --> 00:29:09,415
allora ho bisogno di gestirlo.

420
00:29:09,415 --> 00:29:12,820
Quindi 'se erra' allora 'getta la erra'.

421
00:29:12,820 --> 00:29:21,787
Altrimenti, abbiamo creato il ruolo.

422
00:29:21,787 --> 00:29:28,625
Quindi ora ho bisogno di mappare questo ruolo a questo particolare utente che ho appena creato.

423
00:29:28,625 --> 00:29:31,658
Questo utente che ho appena creato qui.

424
00:29:31,658 --> 00:29:36,660
Questo utente. Voglio dare a questo utente quel ruolo di amministratore.

425
00:29:36,660 --> 00:29:39,140
Quindi, dal momento che ho creato questo ruolo dal nome admin,

426
00:29:39,140 --> 00:29:47,167
quindi diremo, role.principals.create.

427
00:29:47,167 --> 00:29:56,954
Quindi questo è il modo in cui si crea una mappatura tra il ruolo e un particolare utente qui.

428
00:29:56,954 --> 00:29:59,370
Quindi diremo, ruolo.principals.create.

429
00:29:59,370 --> 00:30:01,735
Quindi questa è la sintassi lì.

430
00:30:01,735 --> 00:30:17,320
Diciamo, PrincipalType: RoleMapping.User

431
00:30:17,320 --> 00:30:25,330
qui e prenderai

432
00:30:25,330 --> 00:30:32,385
un id principale qui che è gli utenti.

433
00:30:32,385 --> 00:30:36,320
Ora a cosa si riferisce questo utente?

434
00:30:36,320 --> 00:30:40,418
Questo utenti si riferisce a questo che è appena entrato.

435
00:30:40,418 --> 00:30:43,520
Così, quando abbiamo creato questi utenti,

436
00:30:43,520 --> 00:30:49,335
allora il cliente deve creare un ritorno di successo a noi qui.

437
00:30:49,335 --> 00:30:51,905
Quindi questo è quello che userò qui.

438
00:30:51,905 --> 00:30:53,240
Diciamo, gli utenti [0].

439
00:30:53,240 --> 00:30:58,430
Quindi questo sarebbe un array di utenti che sono stati creati e contengono solo uno di essi.

440
00:30:58,430 --> 00:31:01,748
Ecco perché sto dicendo utente [0].

441
00:31:01,748 --> 00:31:08,037
E poi assegneremo l'ID di quell'utente qui.

442
00:31:08,037 --> 00:31:14,215
Quindi questo è il modo in cui creeremo un RoleMapping tra il ruolo che abbiamo appena creato

443
00:31:14,215 --> 00:31:20,639
, questo ruolo, e quindi mapparlo al cliente che abbiamo appena creato.

444
00:31:20,639 --> 00:31:29,315
Ora questo ci porta anche ai parametri, la funzione di callback.

445
00:31:29,315 --> 00:31:33,735
E in questa funzione di callback diremo semplicemente,

446
00:31:33,735 --> 00:31:35,950
se (err) lancia (err).

447
00:31:35,950 --> 00:31:41,825
Altrimenti non siamo davvero interessati a sapere cos'altro è successo lì.

448
00:31:41,825 --> 00:31:44,055
Questo è tutto. Allora, ecco come.

449
00:31:44,055 --> 00:31:46,870
Quindi, se il ruolo denominato admin non esiste,

450
00:31:46,870 --> 00:31:48,819
creeremo quel ruolo.

451
00:31:48,819 --> 00:31:53,785
Se non- Quindi questa è la

452
00:31:53,785 --> 00:32:01,170
parte 'else' in cui avrò ancora bisogno di fare questa mappatura.

453
00:32:01,170 --> 00:32:08,140
Quindi fammi copiare quel codice e poi lo farò esattamente qui.

454
00:32:08,140 --> 00:32:15,834
Quindi role.principals.create e quindi mappare questo per l'utente lì.

455
00:32:15,834 --> 00:32:17,980
Quindi, se il ruolo di amministratore esiste già,

456
00:32:17,980 --> 00:32:20,730
tutto ciò che devono fare è fare la mappatura.

457
00:32:20,730 --> 00:32:28,420
Quindi questo sarà memorizzato nel modello RoleMapping nel nostro database. Questo è tutto.

458
00:32:28,420 --> 00:32:34,520
Quindi questo pezzo di codice che inseriamo nel file script.js cercherà prima di

459
00:32:34,520 --> 00:32:41,765
scoprire se esiste un utente amministratore e quell'utente è identificato dal nome admin.

460
00:32:41,765 --> 00:32:50,210
In caso contrario, l'utente verrà creato e quindi creerà il ruolo per l'utente.

461
00:32:50,210 --> 00:32:52,065
Verrà creato un ruolo denominato admin.

462
00:32:52,065 --> 00:32:53,865
Se quel ruolo esiste,

463
00:32:53,865 --> 00:32:54,950
allora lo useremo.

464
00:32:54,950 --> 00:32:56,705
Altrimenti creeremo il ruolo.

465
00:32:56,705 --> 00:33:01,485
E poi creeremo questa mappatura tra il ruolo e l'utente.

466
00:33:01,485 --> 00:33:03,940
Quindi loopback ci permette di fare il RoleMapping.

467
00:33:03,940 --> 00:33:07,310
Quindi dire che questo utente non è a questo ruolo.

468
00:33:07,310 --> 00:33:10,395
Quindi questa mappatura viene eseguita utilizzando questa istruzione.

469
00:33:10,395 --> 00:33:14,010
Questo completa la configurazione dei nostri server.

470
00:33:14,010 --> 00:33:18,305
In modo che un utente amministratore venga creato e che l'utente amministratore

471
00:33:18,305 --> 00:33:24,155
otterrà automaticamente il ruolo dell'amministratore come configurato qui.

472
00:33:24,155 --> 00:33:27,675
Questo è tutto. Salviamo le modifiche a script.js.

473
00:33:27,675 --> 00:33:32,015
E ora i nostri server di loopback dovrebbero essere pronti.

474
00:33:32,015 --> 00:33:38,840
Quindi ora andremo e inizieremo il nostro server di ritorno e poi controlleremo cosa possiamo fare con questo.

475
00:33:38,840 --> 00:33:41,085
Andando ai terminali,

476
00:33:41,085 --> 00:33:43,060
iniziamo il server di loopback.

477
00:33:43,060 --> 00:33:49,428
Quindi diremo, npm start e poi il nostro server dovrebbe essere attivo e funzionante.

478
00:33:49,428 --> 00:33:53,220
Andiamo a Explorer e poi sfogliare le informazioni lì.

479
00:33:53,220 --> 00:33:55,890
E questo server di loopback si sarà

480
00:33:55,890 --> 00:33:59,535
connesso automaticamente al mio MongoDP perché ho impostato la connessione.

481
00:33:59,535 --> 00:34:03,415
Andando al mio browser,

482
00:34:03,415 --> 00:34:05,610
fammi ricaricare questo.

483
00:34:05,610 --> 00:34:07,879
E quando ricarico questo,

484
00:34:07,879 --> 00:34:12,450
ora vedrai che abbiamo un nuovo cliente che è stato creato qui.

485
00:34:12,450 --> 00:34:14,705
L' utente esisteva già in precedenza.

486
00:34:14,705 --> 00:34:17,840
I piatti, i leader e le promozioni sono tutti lì.

487
00:34:17,840 --> 00:34:20,325
Eseguiamo un get sui piatti.

488
00:34:20,325 --> 00:34:23,250
Ora che questo è collegato alla bocca MongoDB,

489
00:34:23,250 --> 00:34:26,845
il mio MongoDB ha già alcuni piatti lì dentro.

490
00:34:26,845 --> 00:34:28,235
Se il tuo MongoDB è vuoto,

491
00:34:28,235 --> 00:34:31,821
puoi pubblicare alcuni piatti usando il post qui.

492
00:34:31,821 --> 00:34:33,995
Quindi proviamolo.

493
00:34:33,995 --> 00:34:38,040
Quando faccio un'operazione get sui piatti barra,

494
00:34:38,040 --> 00:34:42,945
vedrete che nel corpo di risposta-

495
00:34:42,945 --> 00:34:48,090
Tutti i piatti che esistono nel mio database sono stati recuperati.

496
00:34:48,090 --> 00:34:52,995
Allo stesso modo, posso fare un GET sulle

497
00:34:52,995 --> 00:35:01,900
promozioni e dovrei vedere la promozione che esiste già nel mio database lì.

498
00:35:01,900 --> 00:35:04,845
Quindi, puoi vedere che la promozione esiste già lì.

499
00:35:04,845 --> 00:35:09,978
Quindi, questo ci mostra come possiamo recuperare informazioni.

500
00:35:09,978 --> 00:35:12,485
Ora, proviamo a postare un nuovo piatto.

501
00:35:12,485 --> 00:35:14,185
Quindi, per pubblicare un nuovo piatto,

502
00:35:14,185 --> 00:35:16,675
andiamo al POST qui.

503
00:35:16,675 --> 00:35:18,715
Fammi copiare questo.

504
00:35:18,715 --> 00:35:20,035
Ovviamente,

505
00:35:20,035 --> 00:35:22,080
in questo momento, perché dal momento che non sono un loggato,

506
00:35:22,080 --> 00:35:26,180
non mi sarà permesso di postare il piatto così,

507
00:35:26,180 --> 00:35:31,615
ma dimostrerò che a voi sono solo copiare e incollare queste informazioni qui,

508
00:35:31,615 --> 00:35:34,120
e cercheremo di postare quel piatto,

509
00:35:34,120 --> 00:35:36,010
e poi quando provo a postare il piatto, il

510
00:35:36,010 --> 00:35:40,660
mio server risponde immediatamente con questo errore dicendo, AUTORIZATION_REQUISED.

511
00:35:40,660 --> 00:35:42,790
Non sei autorizzato a eseguire questa operazione.

512
00:35:42,790 --> 00:35:46,146
Quindi, ecco perché non sei autorizzato a fare questa operazione.

513
00:35:46,146 --> 00:35:48,505
Ora, come ti autorizzi?

514
00:35:48,505 --> 00:35:50,315
Quindi, per autorizzarti,

515
00:35:50,315 --> 00:35:58,450
ora ricorda che abbiamo già creato un utente con il nome admin,

516
00:35:58,450 --> 00:36:05,240
e questo utente admin esiste già come cliente qui.

517
00:36:05,240 --> 00:36:11,495
Quindi, andando negli endpoint dell'API REST del cliente,

518
00:36:11,495 --> 00:36:12,835
se scorri verso il

519
00:36:12,835 --> 00:36:16,925
basso, qui sotto, vedrai l'accesso di questo cliente.

520
00:36:16,925 --> 00:36:20,220
Quindi, quando fai un POST sul login del cliente.

521
00:36:20,220 --> 00:36:22,430
Quindi, per il login del cliente,

522
00:36:22,430 --> 00:36:26,273
scorri qui e poi qui chiede le credenziali.

523
00:36:26,273 --> 00:36:27,540
Quindi, nelle credenziali,

524
00:36:27,540 --> 00:36:35,190
possiamo digitare il nome utente tra virgolette doppie, e diremo,

525
00:36:35,190 --> 00:36:40,570
Admin, e poi password,

526
00:36:40,570 --> 00:36:48,665
diremo, password, e poi pubblicheremo questo.

527
00:36:48,665 --> 00:36:50,450
E poi quando lo

528
00:36:50,450 --> 00:36:54,365
pubblicherai, noterai che nella risposta,

529
00:36:54,365 --> 00:36:57,764
LoopBack mi invierà indietro queste informazioni.

530
00:36:57,764 --> 00:36:59,660
Ora, all'interno di queste informazioni,

531
00:36:59,660 --> 00:37:06,725
questo particolare id che invia indietro è l'accesToken per il mio server LoopBack.

532
00:37:06,725 --> 00:37:09,835
Quindi, posso semplicemente copiare questo AccesStoken qui,

533
00:37:09,835 --> 00:37:13,575
e poi proprio in alto qui,

534
00:37:13,575 --> 00:37:17,735
puoi vedere che questo è Token Not Set, qui.

535
00:37:17,735 --> 00:37:19,660
Dice Token Not Set.

536
00:37:19,660 --> 00:37:22,415
E qui puoi digitare questo accesToken,

537
00:37:22,415 --> 00:37:24,605
e poi dire, Imposta token di accesso.

538
00:37:24,605 --> 00:37:27,245
E poi il tuo AccesStoken verrà impostato,

539
00:37:27,245 --> 00:37:33,525
e quindi tutte le operazioni successive che esegui porteranno automaticamente

540
00:37:33,525 --> 00:37:39,750
questo AccesToken nell'intestazione del mio messaggio di richiesta.

541
00:37:39,750 --> 00:37:45,350
Quindi, in questo modo, ora il mio amministratore sarà autorizzato a fare post di articoli lì.

542
00:37:45,350 --> 00:37:47,480
Quindi, ora che ho effettuato l'accesso come amministratore,

543
00:37:47,480 --> 00:37:49,135
lasciami andare alle promozioni,

544
00:37:49,135 --> 00:37:51,171
e poi pubblicherò una promozione lì,

545
00:37:51,171 --> 00:37:57,098
e ti mostrerò che posso effettivamente pubblicare promozioni.

546
00:37:57,098 --> 00:38:00,885
Quindi, andiamo a un POST,

547
00:38:00,885 --> 00:38:07,250
e poi ci limiteremo a copiare questo, e poi nei dati,

548
00:38:07,250 --> 00:38:13,855
e poi per il nome diremo, Promozione test,

549
00:38:13,855 --> 00:38:24,500
e immagine lo lasceremo come tale, descrizione, Descrizione del test.

550
00:38:30,990 --> 00:38:34,665
E posso postarlo lì,

551
00:38:34,665 --> 00:38:38,180
e vedrai

552
00:38:41,740 --> 00:38:48,265
che non dovrei includere questo id qui perché ho

553
00:38:48,265 --> 00:38:53,710
lasciato che LoopBack assegni automaticamente l'id ad esso.

554
00:38:53,710 --> 00:38:58,325
Lasciami pubblicare questo e poi vedresti che nel corpo della risposta,

555
00:38:58,325 --> 00:39:01,293
la promozione del test è stata postata qui.

556
00:39:01,293 --> 00:39:04,615
E ho appena notato che non ho incluso

557
00:39:04,615 --> 00:39:11,130
la bandiera in primo piano per le mie promozioni e i miei leader.

558
00:39:11,130 --> 00:39:16,180
Quindi, ho intenzione di entrare e includere la bandiera in primo piano come

559
00:39:16,180 --> 00:39:21,930
una delle parti delle mie promozioni lì.

560
00:39:21,930 --> 00:39:26,845
Quindi, ora quando faccio un GET per le promozioni,

561
00:39:26,845 --> 00:39:29,875
vedrai che in quel messaggio di risposta,

562
00:39:29,875 --> 00:39:34,795
vedrai la vecchia promozione che era già nel mio database

563
00:39:34,795 --> 00:39:40,395
e poi la nuova promozione che ho appena pubblicato nel mio database già incluso qui.

564
00:39:40,395 --> 00:39:44,395
Così, ho appena notato che ho bisogno di impostare il flag in primo piano,

565
00:39:44,395 --> 00:39:46,695
vi mostrerò come farlo in un.

566
00:39:46,695 --> 00:39:54,100
Quindi, questo tipo di dimostra a voi come è possibile accedere ed esplorare il vostro server LoopBack.

567
00:39:54,100 --> 00:39:55,420
Permettetemi di distruggere questo token,

568
00:39:55,420 --> 00:39:58,010
quindi rimuoveremo il token

569
00:39:58,010 --> 00:39:59,555
e quindi

570
00:39:59,555 --> 00:40:02,440
cliccheremo su di esso in modo che essenzialmente invii il token di accesso a una

571
00:40:02,440 --> 00:40:05,560
stringa vuota e quindi il mio token non elaborerà più,

572
00:40:05,560 --> 00:40:07,880
quindi ora il mio utente non è più connesso.

573
00:40:07,880 --> 00:40:11,148
Permettetemi di creare un nuovo cliente.

574
00:40:11,148 --> 00:40:16,290
Quindi, per creare un nuovo cliente dirò, clienti POST.

575
00:40:16,290 --> 00:40:20,780
E poi mi limiterò a copiare questo da qui.

576
00:40:20,780 --> 00:40:24,175
Mi creerò un nuovo account qui.

577
00:40:24,175 --> 00:40:26,160
E così, qui,

578
00:40:26,160 --> 00:40:28,620
rimuoverò il regno,

579
00:40:28,620 --> 00:40:32,186
non ne ho bisogno, non ho bisogno dell'id.

580
00:40:32,186 --> 00:40:36,070
Quindi, per il nome

581
00:40:39,750 --> 00:40:46,610
e l'EmailVerified dovrebbero essere impostati automaticamente dal sistema.

582
00:40:46,610 --> 00:40:49,430
Quindi, lasciami accedere come questo utente.

583
00:40:49,430 --> 00:40:52,370
Quindi, sto solo andando a inviare il mio nome, cognome

584
00:40:52,370 --> 00:40:54,440
e l'immagine attualmente,

585
00:40:54,440 --> 00:40:59,745
mi limiterò a impostare una stringa vuota lì, nome utente ed e-mail.

586
00:40:59,745 --> 00:41:01,835
E poi lo proveremo,

587
00:41:01,835 --> 00:41:05,060
e poi ritorna dicendo,

588
00:41:05,060 --> 00:41:08,820
Dettagli: 'password' non può essere vuota.

589
00:41:08,820 --> 00:41:11,285
Quindi, noterai che qui,

590
00:41:11,285 --> 00:41:16,900
dovrei anche includere insieme al nome utente, alla

591
00:41:17,040 --> 00:41:27,834
password e poi, postiamo questo.

592
00:41:27,834 --> 00:41:30,890
Quindi, quando lo pubblichi, ritorna con

593
00:41:30,890 --> 00:41:35,535
il corpo di risposta che dice che ora fai parte del sistema.

594
00:41:35,535 --> 00:41:37,160
Quindi, il tuo nome,

595
00:41:37,160 --> 00:41:40,280
il tuo cognome e il tuo nome utente, il tuo ID email

596
00:41:40,280 --> 00:41:45,706
e l'ID che LoopBack ti assegna vengono inviati a te.

597
00:41:45,706 --> 00:41:52,777
Quindi, questo non è altro che l'id MongoDB come puoi vedere qui.

598
00:41:52,777 --> 00:41:56,150
Quindi, ora che mi sono iscritto come cliente,

599
00:41:56,150 --> 00:41:58,425
dovrei essere in grado di accedere come cliente,

600
00:41:58,425 --> 00:42:01,775
in modo che andrò al login POST qui,

601
00:42:01,775 --> 00:42:04,250
e poi qui invece dell'amministratore,

602
00:42:04,250 --> 00:42:11,710
accederò come nuovo utente a cui ho effettuato l'accesso.

603
00:42:11,710 --> 00:42:14,130
Quindi, poi faccio clic su per Provalo,

604
00:42:14,130 --> 00:42:17,405
vedrai che ritorna con l'id,

605
00:42:17,405 --> 00:42:22,910
quindi mi dà il token per questo utente amministratore qui.

606
00:42:22,910 --> 00:42:30,080
Quindi, con questo abbiamo completato l'esame del server LoopBack che abbiamo appena creato.

607
00:42:30,080 --> 00:42:31,340
E come ho appena detto,

608
00:42:31,340 --> 00:42:36,935
ho notato che le promozioni e i leader non hanno bandiera caratteristica quindi,

609
00:42:36,935 --> 00:42:40,930
ho intenzione di entrare nel codice.

610
00:42:40,930 --> 00:42:43,400
Quindi, supponiamo di dimenticare qualcosa del genere,

611
00:42:43,400 --> 00:42:47,305
allora puoi semplicemente entrare e modificare il codice Json se lo desideri.

612
00:42:47,305 --> 00:42:50,540
Quindi, andrò nel mio codice,

613
00:42:50,540 --> 00:42:52,040
andando al codice,

614
00:42:52,040 --> 00:42:56,635
andrò prima in commons e poi andrò in dishes.json.

615
00:42:56,635 --> 00:42:59,750
E poi nel dishes.json,

616
00:42:59,750 --> 00:43:05,320
vedo questa proprietà in evidenza lì.

617
00:43:05,320 --> 00:43:07,480
Ho intenzione di copiare questa proprietà in primo piano,

618
00:43:07,480 --> 00:43:09,040
e poi andrò in leaders.json,

619
00:43:09,040 --> 00:43:15,151
e poi incollerò quella proprietà caratteristica in un leaders.json,

620
00:43:15,151 --> 00:43:17,750
e anche con promotions.json.

621
00:43:17,750 --> 00:43:22,955
Ho dimenticato di includere questo quando ho creato quei modelli.

622
00:43:22,955 --> 00:43:27,180
Avrei dovuto farlo quando stavo creando il modello stesso quindi,

623
00:43:27,180 --> 00:43:29,960
se dimentichi qualcosa del genere,

624
00:43:29,960 --> 00:43:33,370
allora questo è un altro modo per modificare il tuo modello

625
00:43:33,370 --> 00:43:38,070
e quindi assicurarmi che il tuo modello sia impostato correttamente.

626
00:43:38,070 --> 00:43:40,130
Quindi, questo è tutto.

627
00:43:40,130 --> 00:43:48,575
Quindi, ora le mie promozioni e leader avranno anche la bandiera in primo piano.

628
00:43:48,575 --> 00:43:52,675
Con questo, completiamo questo esercizio.

629
00:43:52,675 --> 00:43:56,525
In questo esercizio, abbiamo visto come possiamo impostare

630
00:43:56,525 --> 00:44:03,555
un nuovo modello estendendo una classe modello di base che è già in LoopBack.

631
00:44:03,555 --> 00:44:07,250
Abbiamo anche visto come

632
00:44:07,250 --> 00:44:11,540
è possibile impostare i controlli di accesso utilizzando gli elenchi di controllo di accesso supportati da LoopBack.

633
00:44:11,540 --> 00:44:13,970
Con questo, completiamo questo esercizio.

634
00:44:13,970 --> 00:44:16,835
Questo è un buon momento per voi di fare un ottenere coperto con

635
00:44:16,835 --> 00:44:22,450
il messaggio LoopBack origini dati e controllo di accesso.