1
00:00:03,550 --> 00:00:06,360
No exercício anterior,

2
00:00:06,360 --> 00:00:10,860
vimos como foi fácil para nós configurar e, em seguida,

3
00:00:10,860 --> 00:00:15,950
andaime um servidor de destinatários usando o framework LoopBack.

4
00:00:15,950 --> 00:00:20,895
Vemos que esta estrutura LoopBack suporta todo um espectro

5
00:00:20,895 --> 00:00:23,040
dos endpoints destinatários e

6
00:00:23,040 --> 00:00:26,324
todas as operações dos endpoints destinatários automaticamente para nós,

7
00:00:26,324 --> 00:00:28,590
quando andaimes nossa aplicação.

8
00:00:28,590 --> 00:00:31,755
Neste exercício, veremos como podemos conectar

9
00:00:31,755 --> 00:00:35,800
nosso servidor LoopBack a um banco de dados back-end,

10
00:00:35,800 --> 00:00:38,926
ou MongoDB nesta instância,

11
00:00:38,926 --> 00:00:45,565
e também veremos como podemos configurar vários controles de acesso nos endpoints do destinatário.

12
00:00:45,565 --> 00:00:47,575
Assim, usando os controles de acesso,

13
00:00:47,575 --> 00:00:52,010
podemos especificar que tipo de operações podem ser realizadas nos endpoints do destinatário,

14
00:00:52,010 --> 00:00:56,730
e quem terá permissão para realizar essas operações.

15
00:00:56,730 --> 00:01:02,385
Assim, por exemplo, um usuário não autenticado ou um convidado só pode

16
00:01:02,385 --> 00:01:08,666
acessar informações ou fazer uma operação get nos pontos finais do destinatário,

17
00:01:08,666 --> 00:01:13,484
um usuário autenticado também seria capaz de fazer o mesmo,

18
00:01:13,484 --> 00:01:21,240
mas apenas um administrador seria capaz de gravar dados no meu servidor.

19
00:01:21,240 --> 00:01:27,025
Assim, qualquer operação de put, post e delete só pode ser realizada por um administrador.

20
00:01:27,025 --> 00:01:32,535
Ao longo do caminho, também veremos como podemos configurar uma conta de administrador em nosso servidor LoopBack

21
00:01:32,535 --> 00:01:35,250
e, em seguida, configurá-la para que

22
00:01:35,250 --> 00:01:38,880
somente o usuário administrador tenha permissão para executar essas operações.

23
00:01:38,880 --> 00:01:42,246
Então é aqui que LoopBack nos permite definir algo

24
00:01:42,246 --> 00:01:46,080
chamado funções associadas a vários usuários.

25
00:01:46,080 --> 00:01:48,645
Assim, cada usuário pode receber uma função.

26
00:01:48,645 --> 00:01:52,170
Como exemplo, você pode falar sobre um usuário comum,

27
00:01:52,170 --> 00:01:55,915
um administrador, um super administrador e assim por diante.

28
00:01:55,915 --> 00:02:00,675
Assim, você pode subdividir seu conjunto de usuários em vários grupos

29
00:02:00,675 --> 00:02:03,793
e, em seguida, atribuir várias funções a eles.

30
00:02:03,793 --> 00:02:09,885
Também vamos olhar para como o modelo de usuário embutido pode ser ainda mais personalizado,

31
00:02:09,885 --> 00:02:11,790
dentro do nosso aplicativo LoopBack,

32
00:02:11,790 --> 00:02:16,290
e como podemos construir outro modelo em cima do modelo de usuário,

33
00:02:16,290 --> 00:02:19,710
e, em seguida, usar o modelo de usuário como a classe base

34
00:02:19,710 --> 00:02:23,400
e desenvolver um modelo de nível superior chamado Modelo de cliente,

35
00:02:23,400 --> 00:02:27,060
que nos permite armazenar informações adicionais para cada um

36
00:02:27,060 --> 00:02:30,999
dos clientes que entrarão em nosso site.

37
00:02:30,999 --> 00:02:38,040
Então, vamos explorar algumas dessas características do LoopBack neste exercício.

38
00:02:38,040 --> 00:02:40,830
Para começar este exercício,

39
00:02:40,830 --> 00:02:42,645
a primeira coisa que eu gostaria que você fizesse,

40
00:02:42,645 --> 00:02:44,040
é iniciar seu servidor MongoDB.

41
00:02:44,040 --> 00:02:49,545
Então aqui estou eu em outra guia terminal na minha pasta MongoDB,

42
00:02:49,545 --> 00:02:52,950
onde eu configurei meu servidor MongoDB anteriormente,

43
00:02:52,950 --> 00:02:59,065
que foi usado pelo meu servidor Express Plus MongoDB nos exercícios anteriores.

44
00:02:59,065 --> 00:03:03,775
Então deixe-me iniciar o servidor MongoDB digitando

45
00:03:03,775 --> 00:03:11,190
MonGod menos D-B dados de parte

46
00:03:11,190 --> 00:03:15,334
nesta pasta e, em seguida, iniciar o meu servidor MongoDB.

47
00:03:15,334 --> 00:03:20,005
Agora, eu vou conectar meu servidor LoopBack ao meu servidor MongoDB.

48
00:03:20,005 --> 00:03:23,920
Então, indo para a minha pasta de servidor LoopBack aqui,

49
00:03:23,920 --> 00:03:28,560
eu tenho que solicitar a fonte de dados do tipo L-B.

50
00:03:28,560 --> 00:03:32,820
Isso nos permitirá configurar a fonte de dados para o nosso servidor LoopBack. O

51
00:03:32,820 --> 00:03:39,460
próprio LoopBack pode se conectar simultaneamente a várias fontes de dados se você assim escolher,

52
00:03:39,460 --> 00:03:41,843
e ele suporta vários tipos.

53
00:03:41,843 --> 00:03:46,800
Ele suporta bancos de dados My Cycle, ele suporta MongoDB,

54
00:03:46,800 --> 00:03:52,175
ele suporta Cloudant que também é outro banco de dados de documentos,

55
00:03:52,175 --> 00:03:58,410
ele suporta Oracle, e muitos outros tipos de bancos de dados.

56
00:03:58,410 --> 00:04:01,830
Então, você pode facilmente configurar isso.

57
00:04:01,830 --> 00:04:04,620
Neste exemplo, vou configurar o meu servidor LoopBack

58
00:04:04,620 --> 00:04:07,810
para falar com o meu MongoDB no back-end.

59
00:04:07,810 --> 00:04:09,445
Então, no prompt,

60
00:04:09,445 --> 00:04:11,590
se digitarmos a fonte de dados L-B,

61
00:04:11,590 --> 00:04:14,610
ela nos solicitará informações.

62
00:04:14,610 --> 00:04:18,155
Então, a primeira coisa que ele vai nos pedir é para o nome da fonte de dados,

63
00:04:18,155 --> 00:04:24,570
e então eu vou configurar este nome de fonte de dados como MongoDB,

64
00:04:24,570 --> 00:04:29,315
e então ele vai me pedir para selecionar o conector.

65
00:04:29,315 --> 00:04:36,120
LoopBack usa conectores para se conectar a vários bancos de dados nos bastidores.

66
00:04:36,120 --> 00:04:38,790
Então, como você pode ver, o banco de dados in-memory que é o que

67
00:04:38,790 --> 00:04:41,795
eles acabaram de usar no exercício anterior,

68
00:04:41,795 --> 00:04:45,105
mas é claro que o banco de dados in-memory significa que uma vez que você desligar seu servidor,

69
00:04:45,105 --> 00:04:47,220
todos os valores desaparecerão,

70
00:04:47,220 --> 00:04:51,080
e isso não é um armazenamento de dados persistente.

71
00:04:51,080 --> 00:04:58,440
Então aqui você vê os vários tipos de bancos de dados que StrongLoop suporta aqui.

72
00:04:58,440 --> 00:05:06,720
Assim, você pode ver a longa lista dos vários bancos de dados que são suportados.

73
00:05:06,720 --> 00:05:09,280
Então você pode ver que ele suporta Cassandra, Redis,

74
00:05:09,280 --> 00:05:15,360
nós tínhamos brevemente referido a estes quando falamos sobre bancos de dados 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 até mesmo diretamente para outros servidores API de descanso para servidores SOAP,

77
00:05:24,325 --> 00:05:26,865
Coachbase e assim por diante.

78
00:05:26,865 --> 00:05:29,040
Então você vê que ele nos fornece

79
00:05:29,040 --> 00:05:33,450
uma longa lista de vários tipos de fontes de dados de lá,

80
00:05:33,450 --> 00:05:36,783
nosso servidor LoopBack pode ler em informações.

81
00:05:36,783 --> 00:05:39,835
No meu caso, eu vou usar o servidor MongoDB então eu

82
00:05:39,835 --> 00:05:43,170
vou configurar o conector MongoDB.

83
00:05:43,170 --> 00:05:44,660
Então, quando eu faço isso,

84
00:05:44,660 --> 00:05:50,775
LoopBack irá instalar automaticamente o conector MongoDB para nós,

85
00:05:50,775 --> 00:05:54,550
e quando ele pede a URL string de conexão,

86
00:05:54,550 --> 00:05:57,810
vamos deixar isso como vazio porque vamos permitir que

87
00:05:57,810 --> 00:06:01,570
ele use a maneira padrão de configuração.

88
00:06:01,570 --> 00:06:04,550
Quando ele pede para o host, vamos dizer

89
00:06:04,550 --> 00:06:09,815
localhost porque estamos executando nosso MongoDB no mesmo computador.

90
00:06:09,815 --> 00:06:11,260
Caso contrário, você especificará

91
00:06:11,260 --> 00:06:16,275
o nome do host do computador no qual você está MongoDB está sendo executado.

92
00:06:16,275 --> 00:06:20,080
Em seguida, o próximo é o número da porta e estamos

93
00:06:20,080 --> 00:06:24,665
usando o nosso número de porta MongoDB padrão 27017,

94
00:06:24,665 --> 00:06:29,186
e ele também vai pedir o nome de usuário e senha, se necessário,

95
00:06:29,186 --> 00:06:32,770
e agora meu MongoDB está em execução sem ter

96
00:06:32,770 --> 00:06:36,850
que fazer qualquer autenticação, então eu deixo o o nome de usuário e senha vazios,

97
00:06:36,850 --> 00:06:38,575
e o nome do banco de dados.

98
00:06:38,575 --> 00:06:44,490
O nome do banco de dados no servidor MongoDB que está sendo executado em segundo plano,

99
00:06:44,490 --> 00:06:47,390
o nome do banco de dados há confusão.

100
00:06:47,390 --> 00:06:52,040
Se você se lembrar, esse é o nome do banco de dados que eles configuraram em nosso servidor MongoDB.

101
00:06:52,040 --> 00:06:56,900
E então ele vai nos perguntar se ele deve instalar o conector LoopBack,

102
00:06:56,900 --> 00:06:58,750
e eu vou dizer sim,

103
00:06:58,750 --> 00:07:02,410
e vai realmente ir em frente e instalar o módulo NPM que acessar

104
00:07:02,410 --> 00:07:07,715
o conector LoopBack para o banco de dados MongoDB.

105
00:07:07,715 --> 00:07:09,415
E uma vez que isso é feito,

106
00:07:09,415 --> 00:07:14,630
meu conector Loopback é instalado aqui para que você possa ver que esta é a versão 1.18.1

107
00:07:14,630 --> 00:07:19,910
e meu servidor LoopBack está pronto para falar com meu MongoDB.

108
00:07:19,910 --> 00:07:22,615
Agora antes de prosseguir,

109
00:07:22,615 --> 00:07:26,090
no exercício anterior eu realmente não configurar alguns modelos

110
00:07:26,090 --> 00:07:30,115
e, em seguida, eu especificá-los para ser armazenado no banco de dados,

111
00:07:30,115 --> 00:07:35,295
eu vou precisar ir e atualizá-los para armazenar seus dados no meu MongoDB.

112
00:07:35,295 --> 00:07:41,610
Então, vamos redefinir rapidamente nosso código para o servidor LoopBack.

113
00:07:41,610 --> 00:07:44,770
Isso também nos fornece uma oportunidade de olhar para

114
00:07:44,770 --> 00:07:49,030
o que meu servidor Loopback em si configurou nesta pasta.

115
00:07:49,030 --> 00:07:54,730
Abrindo a pasta LoopBack em nosso editor,

116
00:07:54,730 --> 00:07:58,200
você pode ver que Loopback já tem

117
00:07:58,200 --> 00:08:02,000
um monte de arquivos para fora nesta pasta.

118
00:08:02,000 --> 00:08:04,080
O package.json, é claro, contém

119
00:08:04,080 --> 00:08:10,275
todos os módulos NPM relacionados que foram configurados aqui,

120
00:08:10,275 --> 00:08:17,901
e aqui você pode ver que o próprio LoopBack configurou o módulo LoopBack NPM,

121
00:08:17,901 --> 00:08:20,970
o módulo de inicialização LoopBack e, em

122
00:08:20,970 --> 00:08:24,840
particular, deixe-me chamar sua atenção para o LoopBack MongoDB conector,

123
00:08:24,840 --> 00:08:32,055
que tínhamos acabado de instalar há pouco tempo, e muitos outros.

124
00:08:32,055 --> 00:08:36,150
Em particular, a configuração para o servidor Loopback é toda

125
00:08:36,150 --> 00:08:40,075
armazenada principalmente em arquivos Json aqui,

126
00:08:40,075 --> 00:08:44,970
com javascriptcore adicional sempre que necessário.

127
00:08:44,970 --> 00:08:50,670
Vamos procurar a personalização do código javascript um pouco mais tarde.

128
00:08:50,670 --> 00:08:53,875
Deixe-me chamar a sua atenção para esta pasta chamada comum.

129
00:08:53,875 --> 00:08:55,850
Nesta pasta comum,

130
00:08:55,850 --> 00:09:01,725
você verá todos os modelos que configuramos anteriormente.

131
00:09:01,725 --> 00:09:04,860
Então você verá que temos os arquivos Dishes.JSON.

132
00:09:04,860 --> 00:09:09,210
Então, quando você abre o arquivo dishes.json, você vê como LoopBack

133
00:09:09,210 --> 00:09:14,695
armazena todas as informações sobre o modelo de pratos que você acabou de criar,

134
00:09:14,695 --> 00:09:17,790
então ele tem o nome, a base,

135
00:09:17,790 --> 00:09:21,655
e alguns outros valores aqui que ele requer.

136
00:09:21,655 --> 00:09:27,369
E, em seguida, olhar para as propriedades e como todas as propriedades são armazenadas aqui.

137
00:09:27,369 --> 00:09:30,735
Então você vê algumas coisas que são muito fáceis para você

138
00:09:30,735 --> 00:09:34,790
reconhecer que estão no arquivo dishes.json.

139
00:09:34,790 --> 00:09:39,040
Da mesma forma, os leaders.json e as promotions.json.

140
00:09:39,040 --> 00:09:42,171
O arquivo dishes.js é grande,

141
00:09:42,171 --> 00:09:46,007
podemos adicionar algum código de personalização adicional para os pratos,

142
00:09:46,007 --> 00:09:48,050
mas agora não vamos fazer isso,

143
00:09:48,050 --> 00:09:50,755
e então vamos deixá-lo como está.

144
00:09:50,755 --> 00:09:56,130
Então este é o lugar onde você pode adicionar em algum código adicional que pode

145
00:09:56,130 --> 00:10:02,610
precisar ser executado quando você acessar o ponto final de pratos de barra.

146
00:10:02,610 --> 00:10:07,630
Mas agora vamos deixar em branco por enquanto.

147
00:10:07,630 --> 00:10:11,725
Agora vamos também olhar para a pasta do servidor aqui.

148
00:10:11,725 --> 00:10:13,465
E a pasta do servidor,

149
00:10:13,465 --> 00:10:18,745
em particular deixe-me chamar sua atenção para o arquivo datasources.json aqui.

150
00:10:18,745 --> 00:10:20,996
No arquivo fonte de dados,

151
00:10:20,996 --> 00:10:23,740
todas as fontes de dados diferentes serão configuradas aqui.

152
00:10:23,740 --> 00:10:26,470
Então agora, nós só temos o DB que é

153
00:10:26,470 --> 00:10:31,634
o banco de dados in-memory DB que LoopBack por padrão configura,

154
00:10:31,634 --> 00:10:34,045
e, em seguida, o MongoDB que acabamos de configurar,

155
00:10:34,045 --> 00:10:36,700
apenas absorveu a informação que a entrada

156
00:10:36,700 --> 00:10:40,570
foi armazenada em que fontes de dados, arquivo json.

157
00:10:40,570 --> 00:10:46,880
Então, você verá que o próprio LoopBack opera configurando todos esses arquivos

158
00:10:46,880 --> 00:10:50,493
que o próprio framework LoopBack faz uso quando

159
00:10:50,493 --> 00:10:56,332
inicia o servidor API de descanso baseado em Loopback.

160
00:10:56,332 --> 00:11:00,620
Vamos entrar no arquivo model config.json aqui.

161
00:11:00,620 --> 00:11:03,050
O próprio arquivo config.json

162
00:11:03,050 --> 00:11:09,028
armazena muita informação aqui que é útil para nós,

163
00:11:09,028 --> 00:11:13,810
mas aqui, vamos entrar e modificar algumas coisas.

164
00:11:13,810 --> 00:11:20,500
Então, para isso, veremos que há novamente para os pratos,

165
00:11:20,500 --> 00:11:24,965
promoções e líderes, a fonte de dados foi configurada como DB.

166
00:11:24,965 --> 00:11:32,150
Então nós vamos modificar isso para MongoDB aqui.

167
00:11:32,150 --> 00:11:34,700
Não só para este,

168
00:11:34,700 --> 00:11:39,053
eles também vão mudar isso para promoções, e também líderes, o que

169
00:11:39,053 --> 00:11:45,590
significa, que todos esses três vão derivar seus dados do MongoDB.

170
00:11:45,590 --> 00:11:48,720
Além disso, para a função que é definida aqui.

171
00:11:48,720 --> 00:11:50,170
Nós também vamos armazenar em MongoDB.

172
00:11:50,170 --> 00:11:53,635
Vamos logo ver como vamos fazer uso da função,

173
00:11:53,635 --> 00:11:56,290
e também do RoleMapping aqui.

174
00:11:56,290 --> 00:12:00,675
Vamos entender a razão desses dois em pouco tempo.

175
00:12:00,675 --> 00:12:04,030
E, em seguida, ACL, as listas de controle de acesso,

176
00:12:04,030 --> 00:12:07,740
estes também serão armazenados no MongoDB.

177
00:12:07,740 --> 00:12:10,210
E então, o usuário, também,

178
00:12:10,210 --> 00:12:12,105
vamos armazená-lo no MongoDB,

179
00:12:12,105 --> 00:12:13,848
e então eles vão deixá-lo lá.

180
00:12:13,848 --> 00:12:17,175
Então, estas são as modificações que você deve fazer para

181
00:12:17,175 --> 00:12:23,744
o arquivo model-config.json e, em seguida, salvar as alterações.

182
00:12:23,744 --> 00:12:27,239
Como mencionei anteriormente, Loopback por padrão,

183
00:12:27,239 --> 00:12:29,705
suporta este modelo chamado, usuário,

184
00:12:29,705 --> 00:12:33,215
que é usado para suportar autenticação de usuário.

185
00:12:33,215 --> 00:12:36,890
O próprio modelo de usuário armazena apenas três propriedades diferentes.

186
00:12:36,890 --> 00:12:40,100
O nome de usuário, o endereço de email

187
00:12:40,100 --> 00:12:42,890
e as informações relacionadas à senha.

188
00:12:42,890 --> 00:12:44,060
Agora, se eles quiserem ter

189
00:12:44,060 --> 00:12:49,125
uma maneira mais elaborada de armazenar informações adicionais sobre os usuários.

190
00:12:49,125 --> 00:12:54,200
Em seguida, eles podem subclasse este modelo de base de usuários

191
00:12:54,200 --> 00:12:56,180
e, em seguida, fazer uso disso.

192
00:12:56,180 --> 00:12:57,950
Então, neste próximo passo,

193
00:12:57,950 --> 00:13:01,880
vou criar outro modelo chamado, o modelo do cliente,

194
00:13:01,880 --> 00:13:08,490
que usará o usuário como modelo base para o seu funcionamento.

195
00:13:08,490 --> 00:13:13,005
E o modelo do cliente em si armazenará informações adicionais sobre os usuários.

196
00:13:13,005 --> 00:13:14,255
Então, no modelo do cliente,

197
00:13:14,255 --> 00:13:16,820
vou armazenar as coisas como o primeiro nome,

198
00:13:16,820 --> 00:13:20,900
o sobrenome, e a imagem para o usuário e assim por diante.

199
00:13:20,900 --> 00:13:24,035
Assim, o cliente atuará exatamente como o modelo do usuário,

200
00:13:24,035 --> 00:13:29,889
que já vem com seu próprio conjunto de métodos.

201
00:13:29,889 --> 00:13:32,780
Assim, o modelo de usuário é usado para a autenticação do usuário, para

202
00:13:32,780 --> 00:13:34,700
que você possa digitar o nome de usuário e a senha,

203
00:13:34,700 --> 00:13:35,930
e fazer login e sair.

204
00:13:35,930 --> 00:13:41,850
Então, quando criamos este modelo de cliente com base na classe base do modelo de usuário,

205
00:13:41,850 --> 00:13:44,742
o modelo de cliente também suportará as

206
00:13:44,742 --> 00:13:47,680
operações de login e logout usando este modelo de cliente.

207
00:13:47,680 --> 00:13:51,880
Então, podemos fazer login no usuário e sair do usuário e assim por diante.

208
00:13:51,880 --> 00:13:56,520
Então, a autenticação do usuário vem automaticamente para a direita.

209
00:13:56,520 --> 00:13:59,750
Então, para criar o modelo do cliente, no prompt,

210
00:13:59,750 --> 00:14:03,340
digite lb model e para o nome do modelo,

211
00:14:03,340 --> 00:14:06,440
digitaremos Cliente.

212
00:14:06,440 --> 00:14:10,700
E o DataSource, vou escolhê-lo como MongoDB.

213
00:14:10,700 --> 00:14:15,080
E, em seguida, quando ele pede para selecionar a classe base do modelo,

214
00:14:15,080 --> 00:14:17,435
em vez de usar o PersistedModel,

215
00:14:17,435 --> 00:14:18,875
vamos mover para baixo

216
00:14:18,875 --> 00:14:23,570
e, em seguida, selecionar o usuário como a classe base.

217
00:14:23,570 --> 00:14:27,215
Então, dessa forma, ele irá derivar todas as suas propriedades

218
00:14:27,215 --> 00:14:31,275
da classe de usuário base que já está incorporada em Loopback.

219
00:14:31,275 --> 00:14:35,370
E então vamos expor isso com a API REST,

220
00:14:35,370 --> 00:14:39,353
e o MT plural personalizado.

221
00:14:39,353 --> 00:14:42,765
E então isso estaria na pasta comum.

222
00:14:42,765 --> 00:14:49,081
E para isso, as três propriedades que vamos adicionar são,

223
00:14:49,081 --> 00:14:54,900
primeiro nome, que teríamos a string tipos.

224
00:14:54,900 --> 00:14:58,700
E isso não é obrigatório ou não tem um valor padrão.

225
00:14:58,700 --> 00:15:05,895
E, em seguida, sobrenome novamente como a cadeia de caracteres de tipo

226
00:15:05,895 --> 00:15:08,825
, não obrigatório e nenhum valor padrão.

227
00:15:08,825 --> 00:15:11,860
E, em seguida, imagem da cadeia de caracteres de tipo,

228
00:15:11,860 --> 00:15:15,249
não obrigatório e nenhum valor padrão.

229
00:15:15,249 --> 00:15:18,095
Então, você vê que a própria classe de cliente

230
00:15:18,095 --> 00:15:22,546
carrega propriedades adicionais além da classe de usuário.

231
00:15:22,546 --> 00:15:25,006
a classe de usuário já suporta o nome de usuário,

232
00:15:25,006 --> 00:15:28,465
o e-mail e as informações relacionadas à senha lá.

233
00:15:28,465 --> 00:15:30,185
Então, a classe de cliente,

234
00:15:30,185 --> 00:15:32,030
uma vez que sub classe é a classe base,

235
00:15:32,030 --> 00:15:38,405
vamos obter o nome de usuário e o e-mail automaticamente da classe de usuário.

236
00:15:38,405 --> 00:15:41,870
E agora, quando você vai para o arquivo model-config.jason,

237
00:15:41,870 --> 00:15:46,725
você verá que o modelo de cliente já foi adicionado lá.

238
00:15:46,725 --> 00:15:48,390
E então, nos modelos comuns,

239
00:15:48,390 --> 00:15:51,278
agora você verá o arquivo.json adicionado lá

240
00:15:51,278 --> 00:15:55,365
com essas três propriedades adicionais que adicionamos ao modelo do cliente.

241
00:15:55,365 --> 00:16:02,020
Mas note, que ele especifica a base como a classe de usuário para o modelo de cliente aqui.

242
00:16:02,020 --> 00:16:04,760
Então, é assim que Loopback permite que você tome

243
00:16:04,760 --> 00:16:09,832
uma classe base-model e, em seguida, subclasse que para a classe model.

244
00:16:09,832 --> 00:16:16,340
Então, você verá como Loopback nos permite suportar automaticamente a autenticação de usuário usando

245
00:16:16,340 --> 00:16:23,855
a classe de usuário e, em seguida, nos permite definir até mesmo subclasse adicional do que,

246
00:16:23,855 --> 00:16:29,780
que irá armazenar informações adicionais relacionadas à classe de base de usuários.

247
00:16:29,780 --> 00:16:32,660
Em seguida, vamos configurar o Controle de Acesso para

248
00:16:32,660 --> 00:16:38,210
os vários modelos que já configuramos em nosso servidor Loopback.

249
00:16:38,210 --> 00:16:40,190
Então, para configurar o Controle de Acesso

250
00:16:40,190 --> 00:16:45,170
ou as Listas de Controle de Acesso em Lookback. O

251
00:16:45,170 --> 00:16:49,730
Loopback usa essas Listas de Controle de Acesso como uma forma de especificar que tipo de

252
00:16:49,730 --> 00:16:51,290
operações podem ser executadas nos

253
00:16:51,290 --> 00:16:55,280
diferentes pontos finais da API REST correspondem aos diferentes modelos.

254
00:16:55,280 --> 00:16:58,695
Então, para fazer isso, vamos digitar no prompt lb acl,

255
00:16:58,695 --> 00:17:01,880
ACL significa listas de controle de acesso.

256
00:17:01,880 --> 00:17:06,980
E então, quando isso acabar, diremos,

257
00:17:06,980 --> 00:17:11,960
qual modelo queremos que essa Lista de Controle de Acesso seja aplicada.

258
00:17:11,960 --> 00:17:14,678
E então vamos dizer, todos os modelos existentes.

259
00:17:14,678 --> 00:17:18,845
E vamos dizer, Todas as métricas e propriedades.

260
00:17:18,845 --> 00:17:20,810
E vamos dizer,

261
00:17:20,810 --> 00:17:23,233
Todos os tipos de operações.

262
00:17:23,233 --> 00:17:25,910
E então, vamos dizer, Todos os usuários.

263
00:17:25,910 --> 00:17:28,730
E então diremos, negamos explicitamente o acesso.

264
00:17:28,730 --> 00:17:32,976
Então, estamos primeiro fechando todos os modelos para tudo,

265
00:17:32,976 --> 00:17:34,670
então abriremos lentamente,

266
00:17:34,670 --> 00:17:38,270
quaisquer que sejam as operações que possam ser realizadas por diferentes usuários.

267
00:17:38,270 --> 00:17:40,385
Então, primeiro passo, fechamos

268
00:17:40,385 --> 00:17:45,715
todos os tipos de operações em todos os modelos que temos atualmente.

269
00:17:45,715 --> 00:17:51,740
Em seguida, começaremos lentamente a abrir cada uma das operações, passo a passo.

270
00:17:51,740 --> 00:17:53,300
Agora, o próximo passo,

271
00:17:53,300 --> 00:17:59,960
o que faremos é configurar novamente a próxima Lista de Controle de Acesso.

272
00:17:59,960 --> 00:18:02,525
Na segunda Lista de Controle de Acesso, diremos,

273
00:18:02,525 --> 00:18:06,095
para todos os modelos existentes e diremos,

274
00:18:06,095 --> 00:18:08,930
Todas as métricas e propriedades.

275
00:18:08,930 --> 00:18:13,400
E então, vamos dizer, apenas acesso de leitura.

276
00:18:13,400 --> 00:18:18,416
Ou seja, quando o usuário pode executar as operações GET nessas portas finais.

277
00:18:18,416 --> 00:18:24,680
E essas operações GET podem ser executadas por todos os usuários.

278
00:18:24,680 --> 00:18:27,805
Assim, os usuários podem recuperar informações.

279
00:18:27,805 --> 00:18:31,605
E nós explicitamente concederemos o acesso para isso.

280
00:18:31,605 --> 00:18:35,804
Então, o que significa que as operações GET são permitidas no nó de pontos de extremidade da API REST.

281
00:18:35,804 --> 00:18:37,610
Primeiro, fechamos tudo,

282
00:18:37,610 --> 00:18:40,880
depois abrimos apenas as operações GET para os usuários.

283
00:18:40,880 --> 00:18:46,175
Agora, finalmente, eles vão para cada um dos modelos,

284
00:18:46,175 --> 00:18:49,490
e depois fecham e permitem que certas operações

285
00:18:49,490 --> 00:18:53,068
sejam executadas apenas por certos tipos de usuários.

286
00:18:53,068 --> 00:18:54,625
Então, para fazer isso,

287
00:18:54,625 --> 00:19:00,511
a próxima ACL que vamos configurar é para um modelo específico.

288
00:19:00,511 --> 00:19:03,197
Então, vamos preparar este para pratos.

289
00:19:03,197 --> 00:19:06,445
E diremos, um único método.

290
00:19:06,445 --> 00:19:08,685
E, em seguida, o nome do método é, criar.

291
00:19:08,685 --> 00:19:13,320
Então, o que significa que a criação destes só será permitida por.

292
00:19:13,320 --> 00:19:15,850
Então, novamente, quando ele diz selecionar a função,

293
00:19:15,850 --> 00:19:18,260
em seguida, para a função, vamos dizer, outro.

294
00:19:18,260 --> 00:19:20,530
E então o nome da função seria admin.

295
00:19:20,530 --> 00:19:24,663
Então, o que estamos fazendo por esta operação é que,

296
00:19:24,663 --> 00:19:32,755
estamos dizendo que apenas um usuário administrador pode criar novos pratos ou atualizar pratos existentes.

297
00:19:32,755 --> 00:19:38,535
Então, isso é um pouco fechado, as operações restantes.

298
00:19:38,535 --> 00:19:45,669
Então, vamos fazer o mesmo pelos líderes.

299
00:19:45,669 --> 00:19:48,880
E um único método e, em seguida,

300
00:19:48,880 --> 00:19:53,821
o criar e vamos dizer,

301
00:19:53,821 --> 00:19:58,320
apenas o administrador pode fazer isso.

302
00:19:58,320 --> 00:20:04,330
E, finalmente, também para promoções.

303
00:20:04,330 --> 00:20:05,919
Para promoções.

304
00:20:05,919 --> 00:20:10,210
O método único, o método de criação será permitido

305
00:20:10,210 --> 00:20:15,415
somente por usuários que tenham a função designada como administrador.

306
00:20:15,415 --> 00:20:20,340
Veremos como criaremos usuários com uma função específica na próxima etapa.

307
00:20:20,340 --> 00:20:22,398
Conceder acesso explicitamente.

308
00:20:22,398 --> 00:20:26,995
Agora observe que eu não fechei clientes para criar operações.

309
00:20:26,995 --> 00:20:28,305
Se eu fechar clientes,

310
00:20:28,305 --> 00:20:31,383
ninguém será capaz de se registrar no sistema.

311
00:20:31,383 --> 00:20:33,220
Então, é por isso que vou deixar isso aberto.

312
00:20:33,220 --> 00:20:37,170
Porque, o cliente deve ser capaz de se registrar no sistema.

313
00:20:37,170 --> 00:20:41,364
Então, você pode se inscrever para novas contas no sistema.

314
00:20:41,364 --> 00:20:42,420
Contas de usuário no sistema.

315
00:20:42,420 --> 00:20:45,585
Então, isso será deixado em aberto para as pessoas fazerem.

316
00:20:45,585 --> 00:20:50,800
Então, para permitir que para os clientes, vamos dizer, clientes,

317
00:20:50,800 --> 00:20:59,880
um único método, criar todos os usuários.

318
00:20:59,880 --> 00:21:03,450
Assim, os clientes podem ser criados por todos os usuários, pois isso

319
00:21:03,450 --> 00:21:07,125
permitirá que as pessoas façam login em suas contas.

320
00:21:07,125 --> 00:21:11,820
Finalmente, vamos ver como podemos configurar nosso servidor para iniciar

321
00:21:11,820 --> 00:21:17,590
com um único usuário administrador automático configurado em nosso servidor Loopback.

322
00:21:17,590 --> 00:21:19,300
Então, para fazer isso,

323
00:21:19,300 --> 00:21:20,820
em nosso servidor Loopback,

324
00:21:20,820 --> 00:21:25,015
na pasta do servidor temos esta subpasta de inicialização aqui.

325
00:21:25,015 --> 00:21:28,380
Seja qual for o código que colocamos na subpasta de inicialização,

326
00:21:28,380 --> 00:21:33,385
será executado na inicialização do nosso servidor LoopBack.

327
00:21:33,385 --> 00:21:37,253
Então, aqui, você verá que já temos este authentication.js,

328
00:21:37,253 --> 00:21:38,490
que já está configurado,

329
00:21:38,490 --> 00:21:42,255
um Loopback que irá configurar a autenticação do usuário para nós.

330
00:21:42,255 --> 00:21:44,790
E então temos o root.js que irá configurar

331
00:21:44,790 --> 00:21:49,650
algumas informações adicionais para o nosso servidor de Loopback RAM.

332
00:21:49,650 --> 00:21:52,920
E podemos adicionar arquivos adicionais aqui.

333
00:21:52,920 --> 00:21:55,696
Então, eu vou entrar lá na pasta de inicialização

334
00:21:55,696 --> 00:22:01,111
e, em seguida, adicionar neste arquivo chamado, script.js.

335
00:22:01,111 --> 00:22:03,259
E neste script.js,

336
00:22:03,259 --> 00:22:07,610
vou configurar o código para criar um usuário admin por padrão.

337
00:22:07,610 --> 00:22:08,785
Então, no script.js,

338
00:22:08,785 --> 00:22:12,335
que não será nada além de um módulo NPM baseado em arquivo então,

339
00:22:12,335 --> 00:22:13,995
vamos começar dizendo,

340
00:22:13,995 --> 00:22:21,050
module.exports = função (aplicativo).

341
00:22:21,050 --> 00:22:23,355
O aplicativo é o aplicativo Loopback,

342
00:22:23,355 --> 00:22:28,185
que será fornecido como um parâmetro para esta função para nós.

343
00:22:28,185 --> 00:22:32,072
E assim, podemos fazer uso dele dentro do nosso código aqui.

344
00:22:32,072 --> 00:22:39,585
Então, aqui, vamos primeiro configurar um usuário admin.

345
00:22:39,585 --> 00:22:41,003
Então, para fazer isso, vamos dizer,

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

347
00:22:51,840 --> 00:22:56,580
Então, isso nos dá acesso ao modelo de cliente.

348
00:22:56,580 --> 00:23:03,321
Então vamos dizer, clientes. Findone.

349
00:23:03,321 --> 00:23:08,820
Então, vamos primeiro verificar se um usuário com

350
00:23:08,820 --> 00:23:16,920
o nome de usuário como admin já está configurado no sistema ou não.

351
00:23:16,920 --> 00:23:20,585
Se não, então eu vou criar um usuário admin.

352
00:23:20,585 --> 00:23:30,230
E isso me fornece uma função de retorno de chamada com dois parâmetros, err e usuários.

353
00:23:30,230 --> 00:23:34,470
E dentro deste - Então vamos primeiro tentar

354
00:23:34,470 --> 00:23:39,195
ver se um usuário com seu nome admin já existe.

355
00:23:39,195 --> 00:23:40,800
Se o usuário não existe,

356
00:23:40,800 --> 00:23:42,453
então vamos criar o usuário.

357
00:23:42,453 --> 00:23:43,800
Então, para criar o usuário,

358
00:23:43,800 --> 00:23:49,326
vamos dizer aqui, se não usuários.

359
00:23:49,326 --> 00:23:55,830
Então, se os usuários não é nulo ou se o usuário diz nulo,

360
00:23:55,830 --> 00:24:02,305
então isso significa que não há nenhum usuário admin, então eu preciso criar um usuário admin aqui.

361
00:24:02,305 --> 00:24:09,330
Então, neste caso, vamos dizer, customer.create.

362
00:24:09,330 --> 00:24:19,835
E esta criação leva uma matriz de objetos, se você quiser.

363
00:24:19,835 --> 00:24:30,235
E esta matriz de objetos nos permitirá especificar quais contas de usuário queremos criar.

364
00:24:30,235 --> 00:24:33,575
Portanto, a primeira conta de usuário que eu quero criar ou

365
00:24:33,575 --> 00:24:38,678
a única conta de usuário que eu quero criar é o 'Admin'.

366
00:24:38,678 --> 00:24:41,845
Então este será o administrador padrão para o

367
00:24:41,845 --> 00:24:47,447
meu servidor de loopback e, em seguida, eu posso configurar o e-mail.

368
00:24:47,447 --> 00:24:56,850
Portanto, lembre-se que o modelo de usuário suporta essas propriedades,

369
00:24:56,850 --> 00:25:02,380
confusion.net e, em seguida, senha

370
00:25:02,380 --> 00:25:07,253
que vou configurar como senha.

371
00:25:07,253 --> 00:25:09,790
Você também pode fornecer junto com isso,

372
00:25:09,790 --> 00:25:11,560
o primeiro nome e o sobrenome,

373
00:25:11,560 --> 00:25:14,345
se você quiser, para o usuário administrador.

374
00:25:14,345 --> 00:25:16,975
Mas eu vou deixá-lo como tal,

375
00:25:16,975 --> 00:25:20,640
como vazio porque aqueles não são necessários para o usuário administrador.

376
00:25:20,640 --> 00:25:22,270
Então eu vou deixá-lo lá.

377
00:25:22,270 --> 00:25:28,765
Portanto, este comando acabará criando um novo cliente com o nome 'Admin'.

378
00:25:28,765 --> 00:25:34,480
Então, se este usuário ou o nome “Admin” não existir,

379
00:25:34,480 --> 00:25:36,194
então vamos criar um.

380
00:25:36,194 --> 00:25:43,800
E então aqui temos a função de retorno de chamada.

381
00:25:45,150 --> 00:25:54,240
Então errar usuários.

382
00:25:54,240 --> 00:25:57,965
Agora eu vou dizer,

383
00:25:57,965 --> 00:26:06,850
se errar, nós não sabemos o que ele está tentando fazer então nós simplesmente vamos jogar o erro.

384
00:26:06,850 --> 00:26:12,210
Mas normalmente não esperamos que isso aconteça.

385
00:26:12,210 --> 00:26:17,650
Então, agora, como você designa esse usuário como um usuário administrativo?

386
00:26:17,650 --> 00:26:19,290
Então, agora, quando eu me inscrevo aqui,

387
00:26:19,290 --> 00:26:21,305
eu estou apenas inscrevendo um usuário normal aqui,

388
00:26:21,305 --> 00:26:24,270
mas nós queremos dar um papel especial a este usuário.

389
00:26:24,270 --> 00:26:30,775
Então é aí que o loopback suporta uma maneira de especificar funções para usuários.

390
00:26:30,775 --> 00:26:32,775
Então, para especificar uma função,

391
00:26:32,775 --> 00:26:39,609
vamos var Role = app.models.Role.

392
00:26:39,609 --> 00:26:42,490
Então isso me permitirá criar uma função,

393
00:26:42,490 --> 00:26:44,670
uma nova chamada de função admin aqui.

394
00:26:44,670 --> 00:26:48,600
Então, podemos atribuir drones diferentes para diferentes usuários, se você quiser.

395
00:26:48,600 --> 00:26:50,365
E para junto com isso,

396
00:26:50,365 --> 00:26:55,394
eu também preciso criar um RoleMapping aqui.

397
00:26:55,394 --> 00:27:05,519
Então vamos dizer, app.models.RoleMapping.

398
00:27:05,519 --> 00:27:12,045
E se acontecer que o banco de dados já contém

399
00:27:12,045 --> 00:27:18,821
qualquer RoleMapping que já existe,

400
00:27:18,821 --> 00:27:25,290
então eu vou destruir todos aqueles quando eu iniciar meu servidor.

401
00:27:25,290 --> 00:27:35,650
E então deixe-me tentar descobrir

402
00:27:36,120 --> 00:27:40,550
para ver se uma função com

403
00:27:40,550 --> 00:27:46,130
esse nome admin já

404
00:27:46,130 --> 00:27:53,180
existe no sistema.

405
00:27:53,180 --> 00:27:54,885
Está bem.

406
00:27:54,885 --> 00:27:56,420
E neste leva,

407
00:27:56,420 --> 00:27:57,560
como você esperaria,

408
00:27:57,560 --> 00:28:06,795
uma função de retorno de chamada e dentro daqui vamos dizer, role.findone.

409
00:28:06,795 --> 00:28:10,530
Então, se uma função com o nome admin já existir,

410
00:28:10,530 --> 00:28:11,927
então eu não preciso criar uma.

411
00:28:11,927 --> 00:28:18,710
Caso contrário, se isso não existir,

412
00:28:18,710 --> 00:28:20,427
então eu preciso criar o papel.

413
00:28:20,427 --> 00:28:29,540
Então vamos dizer, role. Create.

414
00:28:29,540 --> 00:28:34,950
Então, vamos criar a função de administrador aqui.

415
00:28:34,950 --> 00:28:45,230
E então isso nos leva a parâmetros err,

416
00:28:45,230 --> 00:28:52,523
papel aqui, na função callback.

417
00:28:52,523 --> 00:28:56,215
Agora, novamente, aqui para lidar com o erro,

418
00:28:56,215 --> 00:29:03,749
vamos apenas copiar este 'if err' e depois colá-lo lá.

419
00:29:03,749 --> 00:29:06,685
Da mesma forma aqui também, se o erro ocorrer,

420
00:29:06,685 --> 00:29:09,415
então eu preciso lidar com isso.

421
00:29:09,415 --> 00:29:12,820
Então “se errar “, então “jogue a mensagem”.

422
00:29:12,820 --> 00:29:21,787
Caso contrário, criamos a função.

423
00:29:21,787 --> 00:29:28,625
Então agora eu preciso mapear essa função para esse usuário específico que eu acabei de criar.

424
00:29:28,625 --> 00:29:31,658
Este usuário que acabei de criar aqui.

425
00:29:31,658 --> 00:29:36,660
Este usuário. Quero dar a esse usuário a função de administrador.

426
00:29:36,660 --> 00:29:39,140
Então, desde que eu criei essa função pelo nome admin,

427
00:29:39,140 --> 00:29:47,167
então vamos dizer, role.principals.create.

428
00:29:47,167 --> 00:29:56,954
Então é assim que você cria um mapeamento entre a função e um usuário específico aqui.

429
00:29:56,954 --> 00:29:59,370
Então vamos dizer, role.principals.create.

430
00:29:59,370 --> 00:30:01,735
Então esta é a sintaxe lá.

431
00:30:01,735 --> 00:30:17,320
Vamos dizer, principalType: RolemApping.User

432
00:30:17,320 --> 00:30:25,330
aqui e você terá

433
00:30:25,330 --> 00:30:32,385
um ID principal aqui que é os usuários.

434
00:30:32,385 --> 00:30:36,320
Agora, o que esse usuário se refere?

435
00:30:36,320 --> 00:30:40,418
Este usuários se refere a isso que acabou de entrar.

436
00:30:40,418 --> 00:30:43,520
Então, quando criamos esses usuários, o

437
00:30:43,520 --> 00:30:49,335
cliente deve criar um retorno bem-sucedido para nós aqui.

438
00:30:49,335 --> 00:30:51,905
Então é isso que vou usar aqui.

439
00:30:51,905 --> 00:30:53,240
Vamos dizer, usuários [0].

440
00:30:53,240 --> 00:30:58,430
Então este seria um array de usuários que foram criados e contêm apenas um deles.

441
00:30:58,430 --> 00:31:01,748
Então é por isso que eu estou dizendo usuário [0].

442
00:31:01,748 --> 00:31:08,037
E, em seguida, vamos atribuir ID desse usuário aqui.

443
00:31:08,037 --> 00:31:14,215
Então é assim que vamos criar um RoleMapping entre a função que acabamos de criar,

444
00:31:14,215 --> 00:31:20,639
essa função, e então mapeá-la para o cliente que acabamos de criar.

445
00:31:20,639 --> 00:31:29,315
Agora isso também nos leva aos parâmetros, a função callback.

446
00:31:29,315 --> 00:31:33,735
E nesta função callback vamos simplesmente dizer,

447
00:31:33,735 --> 00:31:35,950
if (err) throw (err).

448
00:31:35,950 --> 00:31:41,825
Caso contrário, não estamos realmente interessados em saber o que mais aconteceu lá.

449
00:31:41,825 --> 00:31:44,055
É isso. Então é assim.

450
00:31:44,055 --> 00:31:46,870
Portanto, se a função chamada admin não existir,

451
00:31:46,870 --> 00:31:48,819
criaremos essa função.

452
00:31:48,819 --> 00:31:53,785
Se não- Então esta é a

453
00:31:53,785 --> 00:32:01,170
parte 'else' onde eu ainda precisarei fazer este mapeamento.

454
00:32:01,170 --> 00:32:08,140
Então deixe-me copiar esse código e então eu vou fazer exatamente isso aqui.

455
00:32:08,140 --> 00:32:15,834
Então role.principals.create e, em seguida, mapeie isso para o usuário lá.

456
00:32:15,834 --> 00:32:17,980
Então, se a função de administrador já existe,

457
00:32:17,980 --> 00:32:20,730
então tudo o que eles precisam fazer é fazer o mapeamento.

458
00:32:20,730 --> 00:32:28,420
Então, isso será armazenado no modelo RoleMapping em nosso banco de dados. É isso.

459
00:32:28,420 --> 00:32:34,520
Então, esse pedaço de código que colocamos no arquivo script.js primeiro tentará

460
00:32:34,520 --> 00:32:41,765
descobrir se um usuário admin existe e esse usuário é identificado pelo nome admin.

461
00:32:41,765 --> 00:32:50,210
Caso contrário, o usuário será criado e, em seguida, criará a função para o usuário.

462
00:32:50,210 --> 00:32:52,065
Criaremos uma função chamada admin.

463
00:32:52,065 --> 00:32:53,865
Se esse papel existe,

464
00:32:53,865 --> 00:32:54,950
então vamos usar isso.

465
00:32:54,950 --> 00:32:56,705
Caso contrário, criaremos o papel.

466
00:32:56,705 --> 00:33:01,485
E depois disso, criaremos esse mapeamento entre a função e o usuário.

467
00:33:01,485 --> 00:33:03,940
Então loopback nos permite fazer o RoleMapping.

468
00:33:03,940 --> 00:33:07,310
Então dizer que este usuário não é para este papel.

469
00:33:07,310 --> 00:33:10,395
Portanto, este mapeamento é feito usando esta instrução.

470
00:33:10,395 --> 00:33:14,010
Então isso completa a configuração de nossos servidores.

471
00:33:14,010 --> 00:33:18,305
Para que um usuário admin seja criado e que o usuário admin

472
00:33:18,305 --> 00:33:24,155
obtenha automaticamente a função do administrador conforme configurado aqui.

473
00:33:24,155 --> 00:33:27,675
É isso. Vamos salvar as alterações em script.js.

474
00:33:27,675 --> 00:33:32,015
E agora nossos servidores de loopback devem estar prontos.

475
00:33:32,015 --> 00:33:38,840
Então vamos agora começar o nosso servidor de retorno e depois verificar o que podemos fazer com isso.

476
00:33:38,840 --> 00:33:41,085
Indo para os terminais,

477
00:33:41,085 --> 00:33:43,060
vamos iniciar o servidor de loopback.

478
00:33:43,060 --> 00:33:49,428
Então vamos dizer, npm start e, em seguida, nosso servidor deve estar ativo e funcionando.

479
00:33:49,428 --> 00:33:53,220
Vamos para o Explorer e, em seguida, procurar as informações lá.

480
00:33:53,220 --> 00:33:55,890
E este servidor de loopback terá automaticamente

481
00:33:55,890 --> 00:33:59,535
conectado ao meu MongoDP porque eu configurou a conexão.

482
00:33:59,535 --> 00:34:03,415
Indo para o meu navegador,

483
00:34:03,415 --> 00:34:05,610
deixe-me recarregar isto.

484
00:34:05,610 --> 00:34:07,879
E quando eu recarregar isso,

485
00:34:07,879 --> 00:34:12,450
agora você verá que temos um novo cliente que foi criado aqui.

486
00:34:12,450 --> 00:34:14,705
O usuário já existia anteriormente.

487
00:34:14,705 --> 00:34:17,840
Os pratos, líderes e promoções estão todos lá.

488
00:34:17,840 --> 00:34:20,325
Vamos executar um get sobre os pratos.

489
00:34:20,325 --> 00:34:23,250
Agora que isso está ligado à boca MongoDB,

490
00:34:23,250 --> 00:34:26,845
meu MongoDB já tem alguns pratos lá.

491
00:34:26,845 --> 00:34:28,235
Se o seu MongoDB está vazio,

492
00:34:28,235 --> 00:34:31,821
você pode postar alguns pratos usando o post aqui.

493
00:34:31,821 --> 00:34:33,995
Então vamos experimentá-lo.

494
00:34:33,995 --> 00:34:38,040
Quando eu fizer uma operação get sobre os pratos de barra,

495
00:34:38,040 --> 00:34:42,945
você verá que no corpo de resposta -

496
00:34:42,945 --> 00:34:48,090
Todos os pratos que existem no meu banco de dados foram todos buscados.

497
00:34:48,090 --> 00:34:52,995
Da mesma forma, eu posso fazer um GET em

498
00:34:52,995 --> 00:35:01,900
promoções e eu deveria ver a promoção que já existe no meu banco de dados lá.

499
00:35:01,900 --> 00:35:04,845
Então, você pode ver que a promoção já existe lá.

500
00:35:04,845 --> 00:35:09,978
Então, isso nos mostra como podemos buscar informações.

501
00:35:09,978 --> 00:35:12,485
Agora, vamos tentar postar um novo prato.

502
00:35:12,485 --> 00:35:14,185
Então, para postar um novo prato,

503
00:35:14,185 --> 00:35:16,675
vamos para o POST aqui.

504
00:35:16,675 --> 00:35:18,715
Deixa-me copiar isto.

505
00:35:18,715 --> 00:35:20,035
Obviamente, neste momento,

506
00:35:20,035 --> 00:35:22,080
porque desde que eu não sou um logado,

507
00:35:22,080 --> 00:35:26,180
Eu não vou ser permitido para postar o prato assim,

508
00:35:26,180 --> 00:35:31,615
mas eu vou demonstrar que para você é apenas copiar e colar esta informação aqui,

509
00:35:31,615 --> 00:35:34,120
e vamos tentar postar esse prato,

510
00:35:34,120 --> 00:35:36,010
e então quando eu tentar postar o prato,

511
00:35:36,010 --> 00:35:40,660
meu servidor responde imediatamente com este erro dizendo, AUTORIZATION_REQUIRED

512
00:35:40,660 --> 00:35:42,790
Você não está autorizado a fazer esta operação.

513
00:35:42,790 --> 00:35:46,146
Então, é por isso que você não está autorizado a fazer esta operação.

514
00:35:46,146 --> 00:35:48,505
Agora, como você se autoriza?

515
00:35:48,505 --> 00:35:50,315
Então, para se autorizar,

516
00:35:50,315 --> 00:35:58,450
lembre-se agora que já criamos um usuário com o nome admin,

517
00:35:58,450 --> 00:36:05,240
e esse usuário admin já existe como cliente aqui.

518
00:36:05,240 --> 00:36:11,495
Então, entrando nos pontos finais da API REST do cliente,

519
00:36:11,495 --> 00:36:12,835
se você rolar

520
00:36:12,835 --> 00:36:16,925
para baixo, abaixo, você verá o login deste cliente.

521
00:36:16,925 --> 00:36:20,220
Então, quando você faz um POST no login do cliente.

522
00:36:20,220 --> 00:36:22,430
Então, para o login do cliente,

523
00:36:22,430 --> 00:36:26,273
você rolar para cima aqui e, em seguida, aqui ele pede as credenciais.

524
00:36:26,273 --> 00:36:27,540
Então, nas credenciais,

525
00:36:27,540 --> 00:36:35,190
podemos digitar o nome de usuário entre aspas duplas, e vamos dizer,

526
00:36:35,190 --> 00:36:40,570
Admin e, em seguida, senha,

527
00:36:40,570 --> 00:36:48,665
vamos dizer, senha, e então vamos postar isso.

528
00:36:48,665 --> 00:36:50,450
E então, quando você postar,

529
00:36:50,450 --> 00:36:54,365
você vai notar que na resposta,

530
00:36:54,365 --> 00:36:57,764
LoopBack vai me enviar de volta esta informação.

531
00:36:57,764 --> 00:36:59,660
Agora, dentro desta informação,

532
00:36:59,660 --> 00:37:06,725
este id específico que ele envia de volta é o AccessStoken para o meu servidor LoopBack.

533
00:37:06,725 --> 00:37:09,835
Então, eu posso apenas copiar este AccesStoken aqui,

534
00:37:09,835 --> 00:37:13,575
e então bem no topo aqui,

535
00:37:13,575 --> 00:37:17,735
você pode ver que este é Token Not Set, aqui.

536
00:37:17,735 --> 00:37:19,660
Diz Token Not Set.

537
00:37:19,660 --> 00:37:22,415
E aqui você pode digitar este AccessStoken

538
00:37:22,415 --> 00:37:24,605
e, em seguida, dizer, Definir token de acesso.

539
00:37:24,605 --> 00:37:27,245
E, em seguida, seu AccessStoken será definido,

540
00:37:27,245 --> 00:37:33,525
e, em seguida, todas as operações subsequentes que você executar irá automaticamente carregar

541
00:37:33,525 --> 00:37:39,750
este AccessStoken no cabeçalho da minha mensagem de solicitação.

542
00:37:39,750 --> 00:37:45,350
Então, dessa forma, agora meu administrador terá permissão para fazer postagens de itens lá.

543
00:37:45,350 --> 00:37:47,480
Então, agora que eu fiz login como administrador,

544
00:37:47,480 --> 00:37:49,135
deixe-me ir para promoções,

545
00:37:49,135 --> 00:37:51,171
e então eu vou postar uma promoção lá,

546
00:37:51,171 --> 00:37:57,098
e mostrar-lhe que eu realmente posso postar promoções.

547
00:37:57,098 --> 00:38:00,885
Então, vamos para um POST,

548
00:38:00,885 --> 00:38:07,250
e então vamos apenas copiar isso, e, em seguida, nos dados,

549
00:38:07,250 --> 00:38:13,855
e, em seguida, para o nome vamos dizer, Promoção de teste,

550
00:38:13,855 --> 00:38:24,500
e imagem vamos apenas deixá-lo como tal, descrição, Descrição do teste.

551
00:38:30,990 --> 00:38:34,665
E eu posso postá-lo lá,

552
00:38:34,665 --> 00:38:38,180
e você verá

553
00:38:41,740 --> 00:38:48,265
que eu não deveria incluir este id aqui porque eu

554
00:38:48,265 --> 00:38:53,710
deixei LoopBack atribuir automaticamente o id a ele.

555
00:38:53,710 --> 00:38:58,325
Deixe-me postar isso e então você verá que no corpo de resposta,

556
00:38:58,325 --> 00:39:01,293
a promoção de teste foi postada aqui.

557
00:39:01,293 --> 00:39:04,615
E acabei de notar que não incluí

558
00:39:04,615 --> 00:39:11,130
a bandeira em destaque para minhas promoções e meus líderes.

559
00:39:11,130 --> 00:39:16,180
Então, eu vou entrar e incluir a bandeira em destaque como

560
00:39:16,180 --> 00:39:21,930
uma das partes das minhas promoções lá.

561
00:39:21,930 --> 00:39:26,845
Então, agora quando eu fizer um GET para as promoções,

562
00:39:26,845 --> 00:39:29,875
você verá que nessa mensagem de resposta,

563
00:39:29,875 --> 00:39:34,795
você verá a antiga promoção que já estava no meu banco de dados

564
00:39:34,795 --> 00:39:40,395
e, em seguida, a nova promoção que acabei de postar no meu banco de dados já incluída aqui.

565
00:39:40,395 --> 00:39:44,395
Então, eu só notei que eu preciso definir a bandeira em destaque,

566
00:39:44,395 --> 00:39:46,695
eu vou mostrar-lhe como fazer isso em um.

567
00:39:46,695 --> 00:39:54,100
Então, isso tipo de demonstra para você como você pode fazer login e explorar seu servidor LoopBack.

568
00:39:54,100 --> 00:39:55,420
Deixe-me destruir este token,

569
00:39:55,420 --> 00:39:58,010
então nós vamos apenas remover o token,

570
00:39:58,010 --> 00:39:59,555
e então clique sobre isso para

571
00:39:59,555 --> 00:40:02,440
que essencialmente enviará o token de acesso para uma

572
00:40:02,440 --> 00:40:05,560
string vazia e assim meu token não será mais processado,

573
00:40:05,560 --> 00:40:07,880
então agora meu usuário não está mais conectado.

574
00:40:07,880 --> 00:40:11,148
Deixe-me criar um novo cliente.

575
00:40:11,148 --> 00:40:16,290
Então, para criar um novo cliente eu vou dizer, clientes POST.

576
00:40:16,290 --> 00:40:20,780
E depois vou copiar isto daqui.

577
00:40:20,780 --> 00:40:24,175
Vou criar uma nova conta aqui.

578
00:40:24,175 --> 00:40:26,160
E assim, aqui,

579
00:40:26,160 --> 00:40:28,620
eu removerei o realm,

580
00:40:28,620 --> 00:40:32,186
eu não preciso disso, eu não preciso do id.

581
00:40:32,186 --> 00:40:36,070
Então, para o primeiro nome

582
00:40:39,750 --> 00:40:46,610
e o EmailVerified deve ser automaticamente definido pelo sistema.

583
00:40:46,610 --> 00:40:49,430
Então, deixe-me entrar como este usuário.

584
00:40:49,430 --> 00:40:52,370
Então, eu vou apenas enviar meu primeiro nome, sobrenome,

585
00:40:52,370 --> 00:40:54,440
e a imagem atualmente,

586
00:40:54,440 --> 00:40:59,745
eu vou apenas definir uma string vazia lá, nome de usuário e e-mail.

587
00:40:59,745 --> 00:41:01,835
E então vamos experimentá-lo,

588
00:41:01,835 --> 00:41:05,060
e então ele volta dizendo,

589
00:41:05,060 --> 00:41:08,820
Detalhes: 'senha' não pode estar em branco.

590
00:41:08,820 --> 00:41:11,285
Então, você vai notar que aqui,

591
00:41:11,285 --> 00:41:16,900
eu também deve incluir junto com o nome de usuário,

592
00:41:17,040 --> 00:41:27,834
senha e, em seguida, vamos postar isso.

593
00:41:27,834 --> 00:41:30,890
Então, quando você postá-lo, ele volta com

594
00:41:30,890 --> 00:41:35,535
o Corpo de Resposta dizendo que você agora é parte do sistema.

595
00:41:35,535 --> 00:41:37,160
Então, seu primeiro nome,

596
00:41:37,160 --> 00:41:40,280
seu sobrenome e seu nome de usuário, seu ID de e-mail

597
00:41:40,280 --> 00:41:45,706
e o ID que LoopBack atribui a você são enviados de volta para você.

598
00:41:45,706 --> 00:41:52,777
Então, isso não é nada além da ID do MongoDB como você pode ver aqui.

599
00:41:52,777 --> 00:41:56,150
Então, agora que eu me inscrevi como um cliente,

600
00:41:56,150 --> 00:41:58,425
eu devo ser capaz de fazer login como o cliente, para

601
00:41:58,425 --> 00:42:01,775
que eu vá para o POST login aqui,

602
00:42:01,775 --> 00:42:04,250
e então aqui em vez do administrador,

603
00:42:04,250 --> 00:42:11,710
eu vou fazer login como o novo usuário que eu fiz login.

604
00:42:11,710 --> 00:42:14,130
Então, eu clico em Testar,

605
00:42:14,130 --> 00:42:17,405
você verá que ele retorna com o id,

606
00:42:17,405 --> 00:42:22,910
então ele me dá o token para este usuário admin aqui.

607
00:42:22,910 --> 00:42:30,080
Então, com isso, concluímos o exame do servidor LoopBack que acabamos de criar.

608
00:42:30,080 --> 00:42:31,340
E como acabei de mencionar,

609
00:42:31,340 --> 00:42:36,935
notei que as promoções e os líderes não têm bandeira, então,

610
00:42:36,935 --> 00:42:40,930
vou entrar no código.

611
00:42:40,930 --> 00:42:43,400
Então, suponha que você esqueça algo assim,

612
00:42:43,400 --> 00:42:47,305
então você pode simplesmente entrar e editar o código Json se quiser.

613
00:42:47,305 --> 00:42:50,540
Então, eu vou para o meu código,

614
00:42:50,540 --> 00:42:52,040
indo para o código,

615
00:42:52,040 --> 00:42:56,635
eu vou primeiro para o commons e então eu vou para o dishes.json.

616
00:42:56,635 --> 00:42:59,750
E, em seguida, no dishes.json,

617
00:42:59,750 --> 00:43:05,320
eu vejo essa propriedade em destaque lá.

618
00:43:05,320 --> 00:43:07,480
Eu vou copiar esta propriedade em destaque,

619
00:43:07,480 --> 00:43:09,040
e então eu vou para leaders.json,

620
00:43:09,040 --> 00:43:15,151
e então eu vou colar essa propriedade de feição para um leaders.json,

621
00:43:15,151 --> 00:43:17,750
e também com promotions.json.

622
00:43:17,750 --> 00:43:22,955
Esqueci de incluir isso quando criei esses modelos.

623
00:43:22,955 --> 00:43:27,180
Eu deveria ter feito isso quando eu estava criando o modelo em si então,

624
00:43:27,180 --> 00:43:29,960
se você esquecer algo assim,

625
00:43:29,960 --> 00:43:33,370
então esta é outra maneira de editar seu modelo

626
00:43:33,370 --> 00:43:38,070
e, em seguida, certificar-se de que seu modelo está configurado corretamente.

627
00:43:38,070 --> 00:43:40,130
Então, é isso.

628
00:43:40,130 --> 00:43:48,575
Então, agora minhas promoções e líderes também terão a bandeira em destaque definida lá.

629
00:43:48,575 --> 00:43:52,675
Com isso, completamos este exercício.

630
00:43:52,675 --> 00:43:56,525
Neste exercício, vimos como podemos configurar

631
00:43:56,525 --> 00:44:03,555
um novo modelo estendendo uma classe modelo base que já está em LoopBack.

632
00:44:03,555 --> 00:44:07,250
Também vimos como podemos configurar controles de acesso usando

633
00:44:07,250 --> 00:44:11,540
as listas de controle de acesso suportadas pelo LoopBack.

634
00:44:11,540 --> 00:44:13,970
Com isso, completamos este exercício.

635
00:44:13,970 --> 00:44:16,835
Este é um bom momento para você fazer um ficar coberto com

636
00:44:16,835 --> 00:44:22,450
as fontes de dados LoopBack mensagem e controle de acesso.