1
00:00:03,550 --> 00:00:06,360
В предыдущем упражнении

2
00:00:06,360 --> 00:00:10,860
мы видели, как легко было для нас настроить, а затем

3
00:00:10,860 --> 00:00:15,950
эшафот сервера получателей с помощью структуры LoopBack.

4
00:00:15,950 --> 00:00:20,895
Мы видим, что эта структура LoopBack поддерживает весь

5
00:00:20,895 --> 00:00:23,040
спектр конечных точек получателя и

6
00:00:23,040 --> 00:00:26,324
все операции конечных точек получателя автоматически для нас,

7
00:00:26,324 --> 00:00:28,590
когда мы эшафот нашего приложения.

8
00:00:28,590 --> 00:00:31,755
В этом упражнении мы рассмотрим, как мы можем подключить

9
00:00:31,755 --> 00:00:35,800
наш LoopBack сервер к внутренней базе данных,

10
00:00:35,800 --> 00:00:38,926
или MongoDB в этом случае,

11
00:00:38,926 --> 00:00:45,565
и мы также посмотрим, как мы можем настроить различные элементы управления доступом на конечных точках получателей.

12
00:00:45,565 --> 00:00:47,575
Таким образом, используя элементы управления доступом,

13
00:00:47,575 --> 00:00:52,010
мы можем указать, какие операции могут выполняться на конечных точках получателя,

14
00:00:52,010 --> 00:00:56,730
и кому будет разрешено выполнять эти операции.

15
00:00:56,730 --> 00:01:02,385
Так, например, неаутентифицированный пользователь или гость может

16
00:01:02,385 --> 00:01:08,666
получить доступ только к информации или выполнить операцию get на конечных точках получателя,

17
00:01:08,666 --> 00:01:13,484
аутентифицированный пользователь также сможет сделать то же самое,

18
00:01:13,484 --> 00:01:21,240
но только администратор сможет записывать данные на мой сервер.

19
00:01:21,240 --> 00:01:27,025
Таким образом, любые операции put, post и delete могут выполняться только администратором.

20
00:01:27,025 --> 00:01:32,535
По пути мы также увидим, как мы можем настроить учетную запись администратора на нашем сервере LoopBack,

21
00:01:32,535 --> 00:01:35,250
а затем настроить его так, что

22
00:01:35,250 --> 00:01:38,880
только пользователь администратора будет разрешено выполнять эти операции.

23
00:01:38,880 --> 00:01:42,246
Вот где LoopBack позволяет нам определить что-то,

24
00:01:42,246 --> 00:01:46,080
называемое ролями, связанными с различными пользователями.

25
00:01:46,080 --> 00:01:48,645
Таким образом, каждому пользователю может быть назначена роль.

26
00:01:48,645 --> 00:01:52,170
В качестве примера можно говорить о обычном пользователе,

27
00:01:52,170 --> 00:01:55,915
администраторе, супер-админе и так далее.

28
00:01:55,915 --> 00:02:00,675
Таким образом, вы можете разделить свой набор пользователей на различные группы,

29
00:02:00,675 --> 00:02:03,793
а затем назначить им различные роли.

30
00:02:03,793 --> 00:02:09,885
Также мы рассмотрим, как встроенная пользовательская модель может быть дополнительно настроена,

31
00:02:09,885 --> 00:02:11,790
в нашем приложении LoopBack,

32
00:02:11,790 --> 00:02:16,290
и как мы можем построить другую модель поверх пользовательской модели,

33
00:02:16,290 --> 00:02:19,710
а затем использовать пользовательскую модель в качестве базового класса

34
00:02:19,710 --> 00:02:23,400
и разработать модель более высокого уровня под названием Customer Model,

35
00:02:23,400 --> 00:02:27,060
которая позволяет нам хранить дополнительную информацию для каждого

36
00:02:27,060 --> 00:02:30,999
из клиентов, которые войдут на наш сайт.

37
00:02:30,999 --> 00:02:38,040
Итак, давайте рассмотрим некоторые из этих особенностей LoopBack в этом упражнении.

38
00:02:38,040 --> 00:02:40,830
Чтобы начать с этого упражнения,

39
00:02:40,830 --> 00:02:42,645
первое, что я хотел бы, чтобы вы сделали,

40
00:02:42,645 --> 00:02:44,040
это запустить ваш сервер MongoDB.

41
00:02:44,040 --> 00:02:49,545
Итак, здесь я нахожусь на другой вкладке терминала в моей папке MongoDB,

42
00:02:49,545 --> 00:02:52,950
где я настраивал свой сервер MongoDB ранее,

43
00:02:52,950 --> 00:02:59,065
который использовался моим сервером Express Plus MongoDB в предыдущих упражнениях.

44
00:02:59,065 --> 00:03:03,775
Поэтому позвольте мне запустить сервер MongoDB, введя

45
00:03:03,775 --> 00:03:11,190
Mongod минус данные части D-B

46
00:03:11,190 --> 00:03:15,334
в этой папке, а затем запустить мой сервер MongoDB.

47
00:03:15,334 --> 00:03:20,005
Теперь я собираюсь подключить свой сервер LoopBack к моему серверу MongoDB.

48
00:03:20,005 --> 00:03:23,920
Поэтому, перейдя в мою папку сервера LoopBack здесь,

49
00:03:23,920 --> 00:03:28,560
я должен запрашивать источник данных L-B.

50
00:03:28,560 --> 00:03:32,820
Это позволит нам настроить источник данных для нашего сервера LoopBack.

51
00:03:32,820 --> 00:03:39,460
LoopBack сам может одновременно подключаться к нескольким источникам данных, если вы так решите,

52
00:03:39,460 --> 00:03:41,843
и он поддерживает различные виды.

53
00:03:41,843 --> 00:03:46,800
Он поддерживает базы данных My Cycle, он поддерживает MongoDB,

54
00:03:46,800 --> 00:03:52,175
он поддерживает Cloudant, который также является другой базой данных документов

55
00:03:52,175 --> 00:03:58,410
, он поддерживает Oracle и многие другие виды баз данных.

56
00:03:58,410 --> 00:04:01,830
Таким образом, вы можете легко настроить это.

57
00:04:01,830 --> 00:04:04,620
В этом примере я собираюсь настроить свой сервер LoopBack

58
00:04:04,620 --> 00:04:07,810
для разговора с моим MongoDB в бэкэнд.

59
00:04:07,810 --> 00:04:09,445
Поэтому в ответ,

60
00:04:09,445 --> 00:04:11,590
если мы

61
00:04:11,590 --> 00:04:14,610
введем источник данных L-B, он предложит нам информацию.

62
00:04:14,610 --> 00:04:18,155
Итак, первое, что он спросит нас, это имя источника данных,

63
00:04:18,155 --> 00:04:24,570
а затем я настрою это имя источника данных как MongoDB,

64
00:04:24,570 --> 00:04:29,315
а затем он предложит мне выбрать соединитель.

65
00:04:29,315 --> 00:04:36,120
LoopBack использует соединители для подключения к различным базам данных за кулисами.

66
00:04:36,120 --> 00:04:38,790
Как вы можете видеть, БД в памяти, которая является той, которую

67
00:04:38,790 --> 00:04:41,795
они только что использовали в предыдущем упражнении,

68
00:04:41,795 --> 00:04:45,105
но, конечно, БД в памяти означает, что после завершения работы сервера

69
00:04:45,105 --> 00:04:47,220
все значения исчезнут,

70
00:04:47,220 --> 00:04:51,080
и поэтому это не является постоянным хранилищем данных.

71
00:04:51,080 --> 00:04:58,440
Итак, здесь вы видите различные виды баз данных, которые StrongLoop поддерживает здесь.

72
00:04:58,440 --> 00:05:06,720
Таким образом, вы можете увидеть длинный список различных баз данных, которые поддерживаются.

73
00:05:06,720 --> 00:05:09,280
Таким образом, вы можете видеть, что он поддерживает Cassandra, Redis,

74
00:05:09,280 --> 00:05:15,360
мы кратко ссылались на них, когда мы говорили о базах данных NoSQL, MongoDB

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

76
00:05:18,385 --> 00:05:24,325
и даже непосредственно на другие серверы API Rest для SOAP серверов,

77
00:05:24,325 --> 00:05:26,865
Coachbase и так далее.

78
00:05:26,865 --> 00:05:29,040
Таким образом, вы видите, что он

79
00:05:29,040 --> 00:05:33,450
предоставляет нам длинный список различных видов источников данных оттуда,

80
00:05:33,450 --> 00:05:36,783
наш сервер LoopBack может читать в информации.

81
00:05:36,783 --> 00:05:39,835
В моем случае я собираюсь использовать сервер MongoDB, поэтому я

82
00:05:39,835 --> 00:05:43,170
собираюсь настроить соединитель MongoDB.

83
00:05:43,170 --> 00:05:44,660
Поэтому, когда я это сделаю,

84
00:05:44,660 --> 00:05:50,775
LoopBack автоматически установит соединитель MongoDB для нас,

85
00:05:50,775 --> 00:05:54,550
и когда он запрашивает URL-адрес строки соединения,

86
00:05:54,550 --> 00:05:57,810
мы просто оставим это пустым, потому что мы позволим

87
00:05:57,810 --> 00:06:01,570
ему использовать стандартный способ настройки.

88
00:06:01,570 --> 00:06:04,550
Когда он запрашивает хост, мы скажем

89
00:06:04,550 --> 00:06:09,815
localhost, потому что мы запускаем наш MongoDB на том же компьютере.

90
00:06:09,815 --> 00:06:11,260
В противном случае вы укажете

91
00:06:11,260 --> 00:06:16,275
имя хоста компьютера, на котором вы находитесь MongoDB работает.

92
00:06:16,275 --> 00:06:20,080
Затем следующий - номер порта, и мы используем

93
00:06:20,080 --> 00:06:24,665
наш стандартный номер порта MongoDB 27017,

94
00:06:24,665 --> 00:06:29,186
и он также будет запрашивать имя пользователя и пароль, если это необходимо,

95
00:06:29,186 --> 00:06:32,770
и прямо сейчас мой MongoDB работает без

96
00:06:32,770 --> 00:06:36,850
какой-либо аутентификации, поэтому я оставляю имя пользователя и пароль пустыми,

97
00:06:36,850 --> 00:06:38,575
и имя базы данных.

98
00:06:38,575 --> 00:06:44,490
Имя базы данных на сервере MongoDB, который работает за кулисами,

99
00:06:44,490 --> 00:06:47,390
имя базы данных там путаница.

100
00:06:47,390 --> 00:06:52,040
Если вы помните, что это имя базы данных, которые они установили на нашем сервере MongoDB.

101
00:06:52,040 --> 00:06:56,900
И тогда он спросит нас, должен ли он установить разъем LoopBack,

102
00:06:56,900 --> 00:06:58,750
и я скажу да, и на

103
00:06:58,750 --> 00:07:02,410
самом деле будет идти вперед и установить модуль NPM, который получает доступ к

104
00:07:02,410 --> 00:07:07,715
разъему LoopBack к базе данных MongoDB.

105
00:07:07,715 --> 00:07:09,415
И как только это будет сделано,

106
00:07:09,415 --> 00:07:14,630
мой разъем Loopback установлен здесь, так что вы можете видеть, что это версия 1.18.1,

107
00:07:14,630 --> 00:07:19,910
и мой сервер LoopBack готов поговорить с моим MongoDB.

108
00:07:19,910 --> 00:07:22,615
Теперь, прежде чем я продолжу,

109
00:07:22,615 --> 00:07:26,090
в предыдущем упражнении я действительно не настраиваю некоторые модели,

110
00:07:26,090 --> 00:07:30,115
а затем я указываю их для хранения в БД,

111
00:07:30,115 --> 00:07:35,295
мне нужно будет пойти и обновить их, чтобы сохранить свои данные в моем MongoDB.

112
00:07:35,295 --> 00:07:41,610
Итак, давайте быстро сбросим наш код для сервера LoopBack.

113
00:07:41,610 --> 00:07:44,770
Это также дает нам возможность посмотреть,

114
00:07:44,770 --> 00:07:49,030
что мой сервер Loopback настроен в этой папке.

115
00:07:49,030 --> 00:07:54,730
Открывая папку LoopBack в нашем редакторе,

116
00:07:54,730 --> 00:07:58,200
вы можете увидеть, что Loopback уже имеет

117
00:07:58,200 --> 00:08:02,000
эшафот из целой кучи файлов в эту папку.

118
00:08:02,000 --> 00:08:04,080
Пакет.json, конечно, содержит

119
00:08:04,080 --> 00:08:10,275
все связанные модули NPM, которые были настроены здесь,

120
00:08:10,275 --> 00:08:17,901
и здесь вы можете видеть, что сам LoopBack сконфигурировал модуль NPM LoopBack,

121
00:08:17,901 --> 00:08:20,970
загрузочный модуль LoopBack и, в

122
00:08:20,970 --> 00:08:24,840
частности, позвольте мне обратить ваше внимание на LoopBack MongoDB ,

123
00:08:24,840 --> 00:08:32,055
который мы только что установили недавно, и многие другие.

124
00:08:32,055 --> 00:08:36,150
В частности, конфигурация для сервера Loopback

125
00:08:36,150 --> 00:08:40,075
хранится в основном в файлах Json здесь,

126
00:08:40,075 --> 00:08:44,970
с дополнительным javascriptcore всякий раз, когда это необходимо.

127
00:08:44,970 --> 00:08:50,670
Мы рассмотрим настройку кода javascript немного позже.

128
00:08:50,670 --> 00:08:53,875
Позвольте мне обратить ваше внимание на эту папку, называемую общей.

129
00:08:53,875 --> 00:08:55,850
В этой общей папке

130
00:08:55,850 --> 00:09:01,725
вы увидите все модели, которые мы настроили ранее.

131
00:09:01,725 --> 00:09:04,860
Итак, вы увидите, что у нас есть файлы Dishes.JSON.

132
00:09:04,860 --> 00:09:09,210
Поэтому, когда вы открываете файл dishes.json, вы видите, как LoopBack

133
00:09:09,210 --> 00:09:14,695
хранит всю информацию о модели блюд, которую вы только что создали,

134
00:09:14,695 --> 00:09:17,790
поэтому он имеет имя, базу

135
00:09:17,790 --> 00:09:21,655
и некоторые другие значения здесь, которые он требует.

136
00:09:21,655 --> 00:09:27,369
А затем посмотрите на свойства и как все свойства хранятся здесь.

137
00:09:27,369 --> 00:09:30,735
Таким образом, вы видите некоторые вещи, которые очень легко для вас, чтобы

138
00:09:30,735 --> 00:09:34,790
узнать, что они находятся в файле dishes.json.

139
00:09:34,790 --> 00:09:39,040
Аналогичным образом, leaders.json и promotions.json.

140
00:09:39,040 --> 00:09:42,171
Файл dishes.js большой,

141
00:09:42,171 --> 00:09:46,007
мы можем добавить дополнительный код настройки для блюд,

142
00:09:46,007 --> 00:09:48,050
но прямо сейчас мы не собираемся этого делать,

143
00:09:48,050 --> 00:09:50,755
и поэтому мы просто оставим его как есть.

144
00:09:50,755 --> 00:09:56,130
Таким образом, здесь вы можете добавить некоторый дополнительный код, который может

145
00:09:56,130 --> 00:10:02,610
потребоваться выполнить при доступе к конечной точке косой черты.

146
00:10:02,610 --> 00:10:07,630
Но сейчас мы оставим его пустым на данный момент.

147
00:10:07,630 --> 00:10:11,725
Теперь давайте также посмотрим на папку сервера здесь.

148
00:10:11,725 --> 00:10:13,465
И папка сервера,

149
00:10:13,465 --> 00:10:18,745
в частности, позвольте мне обратить ваше внимание на файл datasources.json здесь.

150
00:10:18,745 --> 00:10:20,996
В файле sources.json

151
00:10:20,996 --> 00:10:23,740
все различные источники данных будут настроены здесь.

152
00:10:23,740 --> 00:10:26,470
Итак, прямо сейчас у нас есть только БД, которая является

153
00:10:26,470 --> 00:10:31,634
базой данных БД в памяти, которую LoopBack по умолчанию настраивает,

154
00:10:31,634 --> 00:10:34,045
а затем MongoDB, который мы только что настроили,

155
00:10:34,045 --> 00:10:36,700
только поглотил информацию, что вход

156
00:10:36,700 --> 00:10:40,570
был сохранен в этих источниках данных, json-файле.

157
00:10:40,570 --> 00:10:46,880
Таким образом, вы увидите, что сам LoopBack работает, настраивая все эти файлы,

158
00:10:46,880 --> 00:10:50,493
которые сама структура LoopBack использует при

159
00:10:50,493 --> 00:10:56,332
запуске сервера API отдыха на основе LoopBack.

160
00:10:56,332 --> 00:11:00,620
Давайте перейдем в файл config.json модели здесь.

161
00:11:00,620 --> 00:11:03,050
Сам файл config.json модели

162
00:11:03,050 --> 00:11:09,028
хранит здесь много информации, которая полезна для нас,

163
00:11:09,028 --> 00:11:13,810
но здесь, давайте входим и изменим несколько вещей.

164
00:11:13,810 --> 00:11:20,500
Так что в этом, мы увидим, что есть снова для блюд,

165
00:11:20,500 --> 00:11:24,965
акций и лидеров, источник данных был настроен как DB.

166
00:11:24,965 --> 00:11:32,150
Поэтому мы собираемся изменить это на MongoDB здесь.

167
00:11:32,150 --> 00:11:34,700
Не только для этого,

168
00:11:34,700 --> 00:11:39,053
они также изменят это для продвижения, а также лидеров, что

169
00:11:39,053 --> 00:11:45,590
означает, что все эти три будут получать свои данные из MongoDB.

170
00:11:45,590 --> 00:11:48,720
Кроме того, для роли, которая определена здесь.

171
00:11:48,720 --> 00:11:50,170
Мы также будем хранить в MongoDB.

172
00:11:50,170 --> 00:11:53,635
Мы довольно скоро увидим, как мы будем использовать роль,

173
00:11:53,635 --> 00:11:56,290
а также RoleMapping здесь.

174
00:11:56,290 --> 00:12:00,675
Мы поймем причину этих двух через короткое время.

175
00:12:00,675 --> 00:12:04,030
И затем, ACL, списки управления доступом,

176
00:12:04,030 --> 00:12:07,740
они также будут храниться в MongoDB.

177
00:12:07,740 --> 00:12:10,210
И тогда, пользователь, также,

178
00:12:10,210 --> 00:12:12,105
мы сохраним его в MongoDB,

179
00:12:12,105 --> 00:12:13,848
и тогда они оставят его там.

180
00:12:13,848 --> 00:12:17,175
Таким образом, это изменения, которые вы должны сделать в

181
00:12:17,175 --> 00:12:23,744
файле model-config.json, а затем сохранить изменения.

182
00:12:23,744 --> 00:12:27,239
Как я уже упоминал ранее, Loopback по умолчанию

183
00:12:27,239 --> 00:12:29,705
поддерживает эту модель называется, пользователь,

184
00:12:29,705 --> 00:12:33,215
который используется для поддержки аутентификации пользователя.

185
00:12:33,215 --> 00:12:36,890
Сама модель пользователя хранит только три различных свойства.

186
00:12:36,890 --> 00:12:40,100
Имя пользователя, адрес электронной почты

187
00:12:40,100 --> 00:12:42,890
и сведения, связанные с паролем.

188
00:12:42,890 --> 00:12:44,060
Теперь, если они хотят иметь

189
00:12:44,060 --> 00:12:49,125
более сложный способ хранения дополнительной информации о пользователях.

190
00:12:49,125 --> 00:12:54,200
Затем они могут подклассифицировать эту модель базы пользователей,

191
00:12:54,200 --> 00:12:56,180
а затем использовать ее.

192
00:12:56,180 --> 00:12:57,950
Итак, на следующем шаге

193
00:12:57,950 --> 00:13:01,880
я собираюсь создать еще одну модель под названием, модель клиента,

194
00:13:01,880 --> 00:13:08,490
которая будет использовать пользователя в качестве базовой модели для его функционирования.

195
00:13:08,490 --> 00:13:13,005
А сама модель клиента будет хранить дополнительную информацию о пользователях.

196
00:13:13,005 --> 00:13:14,255
Итак, в модели клиента

197
00:13:14,255 --> 00:13:16,820
я буду хранить такие вещи, как имя,

198
00:13:16,820 --> 00:13:20,900
фамилия, и изображение для пользователя и так далее.

199
00:13:20,900 --> 00:13:24,035
Таким образом, клиент будет действовать точно так же, как пользовательская модель,

200
00:13:24,035 --> 00:13:29,889
которая уже поставляется с собственным набором методов.

201
00:13:29,889 --> 00:13:32,780
Таким образом, пользовательская модель используется для аутентификации пользователя,

202
00:13:32,780 --> 00:13:34,700
поэтому вы можете ввести имя пользователя и пароль,

203
00:13:34,700 --> 00:13:35,930
а также войти и выйти из системы.

204
00:13:35,930 --> 00:13:41,850
Таким образом, когда мы создали эту модель клиента на основе базового класса пользовательской модели,

205
00:13:41,850 --> 00:13:44,742
модель клиента также будет поддерживать

206
00:13:44,742 --> 00:13:47,680
операции входа и выхода из системы при использовании этой модели клиента.

207
00:13:47,680 --> 00:13:51,880
Таким образом, мы можем войти в систему пользователя и выйти из него и так далее.

208
00:13:51,880 --> 00:13:56,520
Таким образом, аутентификация пользователя автоматически приходит вправо.

209
00:13:56,520 --> 00:13:59,750
Таким образом, чтобы создать модель клиента, в подсказке,

210
00:13:59,750 --> 00:14:03,340
введите модель lb и для имени модели,

211
00:14:03,340 --> 00:14:06,440
мы будем набирать Customer.

212
00:14:06,440 --> 00:14:10,700
И DataSource, я выберу его как MongoDB.

213
00:14:10,700 --> 00:14:15,080
И тогда, когда он просит выбрать базовый класс модели,

214
00:14:15,080 --> 00:14:17,435
вместо использования PersistedModel,

215
00:14:17,435 --> 00:14:18,875
мы будем двигаться вниз,

216
00:14:18,875 --> 00:14:23,570
а затем выбрать пользователя в качестве базового класса.

217
00:14:23,570 --> 00:14:27,215
Таким образом, он будет получать все свои свойства

218
00:14:27,215 --> 00:14:31,275
базового пользовательского класса, который уже встроен в Loopback.

219
00:14:31,275 --> 00:14:35,370
И тогда мы выставим это с помощью REST API

220
00:14:35,370 --> 00:14:39,353
и пользовательского множественного числа MT.

221
00:14:39,353 --> 00:14:42,765
И тогда это будет в общей папке.

222
00:14:42,765 --> 00:14:49,081
И для этого, три свойства, которые мы добавим, являются

223
00:14:49,081 --> 00:14:54,900
, имя, которое бы мы имели строку типов.

224
00:14:54,900 --> 00:14:58,700
И это не обязательно или не имеет значения по умолчанию.

225
00:14:58,700 --> 00:15:05,895
И затем фамилия снова в качестве строки типа,

226
00:15:05,895 --> 00:15:08,825
не требуется, и нет значения по умолчанию.

227
00:15:08,825 --> 00:15:11,860
И затем изображение строки типа,

228
00:15:11,860 --> 00:15:15,249
не требуется и нет значения по умолчанию.

229
00:15:15,249 --> 00:15:18,095
Таким образом, вы видите, что сам класс клиента

230
00:15:18,095 --> 00:15:22,546
несет дополнительные свойства в дополнение к классу пользователя.

231
00:15:22,546 --> 00:15:25,006
класс пользователя уже поддерживает имя пользователя,

232
00:15:25,006 --> 00:15:28,465
адрес электронной почты и информацию, связанную с паролем.

233
00:15:28,465 --> 00:15:30,185
Итак, класс клиента,

234
00:15:30,185 --> 00:15:32,030
так как подкласс является базовым классом,

235
00:15:32,030 --> 00:15:38,405
мы автоматически получим имя пользователя и электронную почту из класса пользователя.

236
00:15:38,405 --> 00:15:41,870
И теперь, когда вы перейдете к файлу model-config.jason,

237
00:15:41,870 --> 00:15:46,725
вы увидите, что модель клиента уже была добавлена туда.

238
00:15:46,725 --> 00:15:48,390
А затем в общих моделях

239
00:15:48,390 --> 00:15:51,278
вы увидите добавленный туда файл customer.json

240
00:15:51,278 --> 00:15:55,365
с этими тремя дополнительными свойствами, которые мы добавили в модель клиента.

241
00:15:55,365 --> 00:16:02,020
Но обратите внимание, что он указывает базу в качестве пользовательского класса для модели клиента здесь.

242
00:16:02,020 --> 00:16:04,760
Итак, вот как Loopback позволяет вам взять

243
00:16:04,760 --> 00:16:09,832
класс базовой модели, а затем подкласс, который в класс модели.

244
00:16:09,832 --> 00:16:16,340
Итак, вы увидите, как Loopback позволяет нам автоматически поддерживать аутентификацию пользователей с помощью

245
00:16:16,340 --> 00:16:23,855
пользовательского класса, а затем позволяет нам даже определить дополнительный подкласс этого,

246
00:16:23,855 --> 00:16:29,780
который будет хранить дополнительную информацию, связанную с пользовательским базовым классом.

247
00:16:29,780 --> 00:16:32,660
Далее мы настроим контроль доступа для

248
00:16:32,660 --> 00:16:38,210
различных моделей, которые мы уже установили на нашем сервере Loopback.

249
00:16:38,210 --> 00:16:40,190
Таким образом, чтобы настроить контроль доступа,

250
00:16:40,190 --> 00:16:45,170
или списки управления доступом в Lookback.

251
00:16:45,170 --> 00:16:49,730
Loopback использует эти списки управления доступом как способ указания того, какие

252
00:16:49,730 --> 00:16:51,290
операции могут выполняться

253
00:16:51,290 --> 00:16:55,280
на различных конечных точках REST API, соответствующих различным моделям.

254
00:16:55,280 --> 00:16:58,695
Поэтому, чтобы сделать это, мы напечатаем в командной строке lb acl,

255
00:16:58,695 --> 00:17:01,880
ACL означает списки управления доступом.

256
00:17:01,880 --> 00:17:06,980
И тогда, когда это закончится, мы скажем, к

257
00:17:06,980 --> 00:17:11,960
какой модели мы хотим применить этот список управления доступом.

258
00:17:11,960 --> 00:17:14,678
А потом скажем, все существующие модели.

259
00:17:14,678 --> 00:17:18,845
И мы скажем: «Все метрики и свойства».

260
00:17:18,845 --> 00:17:20,810
И скажем,

261
00:17:20,810 --> 00:17:23,233
все виды операций.

262
00:17:23,233 --> 00:17:25,910
А потом, скажем, «Все пользователи».

263
00:17:25,910 --> 00:17:28,730
И тогда мы скажем, явно запретить доступ.

264
00:17:28,730 --> 00:17:32,976
Итак, мы сначала закрываем все модели для всего,

265
00:17:32,976 --> 00:17:34,670
затем будем медленно открываться,

266
00:17:34,670 --> 00:17:38,270
любые операции, которые могут быть выполнены разными пользователями.

267
00:17:38,270 --> 00:17:40,385
Итак, первый шаг, мы закрыли

268
00:17:40,385 --> 00:17:45,715
все типы операций на всех моделях, которые у нас есть в настоящее время.

269
00:17:45,715 --> 00:17:51,740
Затем мы медленно начнем открывать каждую из операций, шаг за шагом.

270
00:17:51,740 --> 00:17:53,300
Теперь следующий шаг,

271
00:17:53,300 --> 00:17:59,960
то, что мы сделаем, это снова настроить следующий список управления доступом.

272
00:17:59,960 --> 00:18:02,525
Во втором списке управления доступом мы скажем,

273
00:18:02,525 --> 00:18:06,095
для всех существующих моделей и мы скажем,

274
00:18:06,095 --> 00:18:08,930
Все метрики и свойства.

275
00:18:08,930 --> 00:18:13,400
И тогда, скажем, только доступ к чтению.

276
00:18:13,400 --> 00:18:18,416
То есть, когда пользователь может выполнять операции GET на этих конечных портах.

277
00:18:18,416 --> 00:18:24,680
И эти GET операции могут выполняться всеми пользователями.

278
00:18:24,680 --> 00:18:27,805
Таким образом, пользователи могут извлекать информацию.

279
00:18:27,805 --> 00:18:31,605
И мы явно предоставим доступ для этого.

280
00:18:31,605 --> 00:18:35,804
Таким образом, это означает, что операции GET разрешены на узле конечных точек REST API.

281
00:18:35,804 --> 00:18:37,610
Сначала мы все закрыли,

282
00:18:37,610 --> 00:18:40,880
потом открывали только GET операции для пользователей.

283
00:18:40,880 --> 00:18:46,175
Теперь, наконец, они перейдут к каждой из моделей,

284
00:18:46,175 --> 00:18:49,490
а затем закроют и разрешают определенные операции только

285
00:18:49,490 --> 00:18:53,068
определенным типам пользователей.

286
00:18:53,068 --> 00:18:54,625
Поэтому, чтобы сделать это,

287
00:18:54,625 --> 00:19:00,511
следующий список ACL, который мы будем настраивать, предназначен для конкретной модели.

288
00:19:00,511 --> 00:19:03,197
Итак, мы подставим эту для посуды.

289
00:19:03,197 --> 00:19:06,445
И скажем, один метод.

290
00:19:06,445 --> 00:19:08,685
И тогда имя метода: create.

291
00:19:08,685 --> 00:19:13,320
Таким образом, это означает, что их создание будет разрешено только.

292
00:19:13,320 --> 00:19:15,850
Итак, опять же, когда он говорит выбрать роль,

293
00:19:15,850 --> 00:19:18,260
затем для роли, мы скажем, другое.

294
00:19:18,260 --> 00:19:20,530
И тогда имя роли будет admin.

295
00:19:20,530 --> 00:19:24,663
Итак, то, что мы делаем с помощью этой операции,

296
00:19:24,663 --> 00:19:32,755
мы говорим, что только пользователь администратора может создавать новые блюда или обновлять существующие блюда.

297
00:19:32,755 --> 00:19:38,535
Итак, это немного близко, остальные операции.

298
00:19:38,535 --> 00:19:45,669
Итак, давайте сделаем то же самое для лидеров.

299
00:19:45,669 --> 00:19:48,880
И один метод, а затем,

300
00:19:48,880 --> 00:19:53,821
создание и мы скажем,

301
00:19:53,821 --> 00:19:58,320
только администратор может это сделать.

302
00:19:58,320 --> 00:20:04,330
И затем, наконец, также для промо-акций.

303
00:20:04,330 --> 00:20:05,919
Для продвижения по службе.

304
00:20:05,919 --> 00:20:10,210
Единственный метод, метод создания будет разрешен

305
00:20:10,210 --> 00:20:15,415
только пользователями, которые имеют назначенную роль в качестве администратора.

306
00:20:15,415 --> 00:20:20,340
Мы увидим, как мы будем создавать пользователей с определенной ролью на следующем шаге.

307
00:20:20,340 --> 00:20:22,398
Явным образом предоставьте доступ.

308
00:20:22,398 --> 00:20:26,995
Теперь обратите внимание, что я не закрывал клиентов для операций создания.

309
00:20:26,995 --> 00:20:28,305
Если я закрою клиентов,

310
00:20:28,305 --> 00:20:31,383
никто не сможет зарегистрироваться в системе.

311
00:20:31,383 --> 00:20:33,220
Поэтому я оставлю это открытым.

312
00:20:33,220 --> 00:20:37,170
Потому что клиент должен иметь возможность зарегистрироваться в системе.

313
00:20:37,170 --> 00:20:41,364
Таким образом, вы можете подписаться на новые учетные записи в системе.

314
00:20:41,364 --> 00:20:42,420
Учетные записи пользователей в системе.

315
00:20:42,420 --> 00:20:45,585
Таким образом, это будет оставлено открытым для людей.

316
00:20:45,585 --> 00:20:50,800
Таким образом, чтобы разрешить это для клиентов, мы скажем, клиенты,

317
00:20:50,800 --> 00:20:59,880
Один метод, создать всех пользователей.

318
00:20:59,880 --> 00:21:03,450
Таким образом, клиенты могут быть созданы всеми пользователями, потому что это

319
00:21:03,450 --> 00:21:07,125
позволит людям войти в свою учетную запись.

320
00:21:07,125 --> 00:21:11,820
Наконец, мы увидим, как мы можем настроить наш сервер для запуска

321
00:21:11,820 --> 00:21:17,590
с одним пользователем администратора, автоматически настроенным на наш сервер Loopback.

322
00:21:17,590 --> 00:21:19,300
Итак, чтобы сделать это, на

323
00:21:19,300 --> 00:21:20,820
нашем сервере Loopback,

324
00:21:20,820 --> 00:21:25,015
в папке сервера у нас есть эта загрузочная подпапка здесь.

325
00:21:25,015 --> 00:21:28,380
Какой бы код мы ни поместили в загрузочную подпапку,

326
00:21:28,380 --> 00:21:33,385
будет выполнен при запуске нашего сервера LoopBack.

327
00:21:33,385 --> 00:21:37,253
Итак, здесь вы увидите, что у нас уже есть этот authentication.js,

328
00:21:37,253 --> 00:21:38,490
который уже настроен,

329
00:21:38,490 --> 00:21:42,255
Loopback, который будет настраивать аутентификацию пользователя для нас.

330
00:21:42,255 --> 00:21:44,790
И тогда у нас есть root.js, который будет настраивать

331
00:21:44,790 --> 00:21:49,650
некоторую дополнительную информацию для нашего сервера RAM Loopback.

332
00:21:49,650 --> 00:21:52,920
И мы можем добавить дополнительные файлы здесь.

333
00:21:52,920 --> 00:21:55,696
Итак, я собираюсь войти туда в папку загрузки,

334
00:21:55,696 --> 00:22:01,111
а затем добавить в этот файл под названием script.js.

335
00:22:01,111 --> 00:22:03,259
И в этом script.js

336
00:22:03,259 --> 00:22:07,610
я собираюсь настроить код для создания пользователя администратора по умолчанию.

337
00:22:07,610 --> 00:22:08,785
Итак, в script.js,

338
00:22:08,785 --> 00:22:12,335
который будет не чем иным, как файловым модулем NPM, поэтому

339
00:22:12,335 --> 00:22:13,995
мы начнем, сказав,

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

341
00:22:21,050 --> 00:22:23,355
Приложение является приложением Loopback,

342
00:22:23,355 --> 00:22:28,185
которое будет поставлено в качестве параметра этой функции для нас.

343
00:22:28,185 --> 00:22:32,072
Итак, мы можем использовать его в нашем коде здесь.

344
00:22:32,072 --> 00:22:39,585
Итак, здесь мы сначала настроим пользователя администратора.

345
00:22:39,585 --> 00:22:41,003
Итак, чтобы сделать это, скажем,

346
00:22:41,003 --> 00:22:51,840
var Customer = App.Models.Customer.

347
00:22:51,840 --> 00:22:56,580
Таким образом, это дает нам доступ к модели клиента.

348
00:22:56,580 --> 00:23:03,321
Тогда мы скажем, клиенты.

349
00:23:03,321 --> 00:23:08,820
Итак, сначала мы проверим, если пользователь с

350
00:23:08,820 --> 00:23:16,920
именем пользователя в качестве администратора уже настроен в системе или нет.

351
00:23:16,920 --> 00:23:20,585
Если нет, то я собираюсь создать пользователя администратора.

352
00:23:20,585 --> 00:23:30,230
И это предоставляет мне функцию обратного вызова с двумя параметрами, err и пользователями.

353
00:23:30,230 --> 00:23:34,470
И внутри этого - Так что мы сначала попытаемся

354
00:23:34,470 --> 00:23:39,195
увидеть, если пользователь с их именем admin уже существует.

355
00:23:39,195 --> 00:23:40,800
Если пользователь не существует,

356
00:23:40,800 --> 00:23:42,453
то мы создадим пользователя.

357
00:23:42,453 --> 00:23:43,800
Итак, чтобы создать пользователя,

358
00:23:43,800 --> 00:23:49,326
мы скажем здесь, если не пользователи.

359
00:23:49,326 --> 00:23:55,830
Итак, если пользователи не являются нулевыми или если пользователь говорит null,

360
00:23:55,830 --> 00:24:02,305
то это означает, что нет администратора, поэтому мне нужно создать пользователя администратора здесь.

361
00:24:02,305 --> 00:24:09,330
Так что в этом случае, скажем, customer.create.

362
00:24:09,330 --> 00:24:19,835
И это создание принимает массив объектов, если вы хотите.

363
00:24:19,835 --> 00:24:30,235
И этот массив объектов позволит нам указать, какие учетные записи пользователей мы хотим создать.

364
00:24:30,235 --> 00:24:33,575
Таким образом, первая учетная запись пользователя, которую я хочу создать, или

365
00:24:33,575 --> 00:24:38,678
единственная учетная запись пользователя, которую я хочу создать, - это «Администратор».

366
00:24:38,678 --> 00:24:41,845
Таким образом, это будет администратор по умолчанию для

367
00:24:41,845 --> 00:24:47,447
моего сервера замыкания на себя, а затем я могу настроить электронную почту.

368
00:24:47,447 --> 00:24:56,850
Поэтому напомним, что пользовательская модель поддерживает эти свойства,

369
00:24:56,850 --> 00:25:02,380
confusion.net, а затем пароль,

370
00:25:02,380 --> 00:25:07,253
который я настрою как пароль.

371
00:25:07,253 --> 00:25:09,790
Вы также можете указать вместе с этим

372
00:25:09,790 --> 00:25:11,560
имя и фамилию,

373
00:25:11,560 --> 00:25:14,345
если хотите, для пользователя администратора.

374
00:25:14,345 --> 00:25:16,975
Но я собираюсь оставить его как таковой,

375
00:25:16,975 --> 00:25:20,640
как пустой, потому что они не требуются для пользователя администратора.

376
00:25:20,640 --> 00:25:22,270
Так что я оставлю его там.

377
00:25:22,270 --> 00:25:28,765
Таким образом, эта команда в конечном итоге создаст нового клиента с именем «Admin».

378
00:25:28,765 --> 00:25:34,480
Так что если этот пользователь или имя «Admin» не существует,

379
00:25:34,480 --> 00:25:36,194
то мы собираемся его создать.

380
00:25:36,194 --> 00:25:43,800
А затем здесь у нас есть функция обратного вызова.

381
00:25:45,150 --> 00:25:54,240
Так что заблуждайте пользователей.

382
00:25:54,240 --> 00:25:57,965
Теперь я скажу,

383
00:25:57,965 --> 00:26:06,850
если ошибки, мы не знаем, что он пытается сделать, поэтому мы просто выбросим ошибку.

384
00:26:06,850 --> 00:26:12,210
Но обычно мы не ожидаем, что это произойдет.

385
00:26:12,210 --> 00:26:17,650
Итак, как вы назначаете этого пользователя администратором?

386
00:26:17,650 --> 00:26:19,290
Поэтому прямо сейчас, когда я

387
00:26:19,290 --> 00:26:21,305
регистрируюсь здесь, я просто регистрирую обычного пользователя здесь,

388
00:26:21,305 --> 00:26:24,270
но мы хотим дать особую роль этому пользователю.

389
00:26:24,270 --> 00:26:30,775
Вот где loopback поддерживает способ указания ролей для пользователей.

390
00:26:30,775 --> 00:26:32,775
Таким образом, чтобы указать роль,

391
00:26:32,775 --> 00:26:39,609
мы будем var Role = App.models.role.

392
00:26:39,609 --> 00:26:42,490
Таким образом, это позволит мне создать роль,

393
00:26:42,490 --> 00:26:44,670
новую роль вызова администратора здесь.

394
00:26:44,670 --> 00:26:48,600
Таким образом, мы можем назначить разные дроны разным пользователям, если вы хотите.

395
00:26:48,600 --> 00:26:50,365
И вместе с этим

396
00:26:50,365 --> 00:26:55,394
мне также нужно создать RoleMapapping здесь.

397
00:26:55,394 --> 00:27:05,519
Так что скажем, App.models.Rolemapping.

398
00:27:05,519 --> 00:27:12,045
И если так случится, что база данных уже содержит

399
00:27:12,045 --> 00:27:18,821
какой-либо RoleMapping, который уже существует,

400
00:27:18,821 --> 00:27:25,290
то я собираюсь уничтожить всех, когда я запускаю свой сервер.

401
00:27:25,290 --> 00:27:35,650
А затем позвольте мне

402
00:27:36,120 --> 00:27:46,130
попытаться найти,

403
00:27:46,130 --> 00:27:53,180
существует ли в системе роль с этим именем admin.

404
00:27:53,180 --> 00:27:54,885
Хорошо.

405
00:27:54,885 --> 00:27:56,420
И в этом занимает,

406
00:27:56,420 --> 00:27:57,560
как вы ожидали,

407
00:27:57,560 --> 00:28:06,795
функцию обратного вызова и внутри здесь мы скажем, role.findone.

408
00:28:06,795 --> 00:28:10,530
Поэтому, если роль с именем admin уже существует,

409
00:28:10,530 --> 00:28:11,927
мне не нужно ее создавать.

410
00:28:11,927 --> 00:28:18,710
В противном случае, если

411
00:28:18,710 --> 00:28:20,427
этого не существует, мне нужно создать роль.

412
00:28:20,427 --> 00:28:29,540
Так что мы скажем: «Роль.Создай».

413
00:28:29,540 --> 00:28:34,950
Таким образом, мы создадим здесь роль администратора.

414
00:28:34,950 --> 00:28:45,230
И тогда это приводит нас к параметрам err,

415
00:28:45,230 --> 00:28:52,523
роли здесь, в функции обратного вызова.

416
00:28:52,523 --> 00:28:56,215
Теперь снова, здесь, чтобы обработать ошибку,

417
00:28:56,215 --> 00:29:03,749
мы просто скопируем это «если err», а затем вставьте его туда.

418
00:29:03,749 --> 00:29:06,685
Точно так же здесь также, если происходит ошибка,

419
00:29:06,685 --> 00:29:09,415
мне нужно справиться с этим.

420
00:29:09,415 --> 00:29:12,820
Итак, «если ошибка», то «бросьте ошибку».

421
00:29:12,820 --> 00:29:21,787
В противном случае мы создали эту роль.

422
00:29:21,787 --> 00:29:28,625
Итак, теперь мне нужно сопоставить эту роль этому конкретному пользователю, которого я только что создал.

423
00:29:28,625 --> 00:29:31,658
Этот пользователь, который я только что создал здесь.

424
00:29:31,658 --> 00:29:36,660
Этот пользователь. Я хочу дать этому пользователю эту роль администратора.

425
00:29:36,660 --> 00:29:39,140
Так как я создал эту роль по имени admin,

426
00:29:39,140 --> 00:29:47,167
так что мы скажем, role.principals.create.

427
00:29:47,167 --> 00:29:56,954
Вот как вы создаете сопоставление между ролью и конкретным пользователем здесь.

428
00:29:56,954 --> 00:29:59,370
Так что скажем, role.principals.create.

429
00:29:59,370 --> 00:30:01,735
Таким образом, это синтаксис.

430
00:30:01,735 --> 00:30:17,320
Мы скажем, PrincipalType: RolemApping.User

431
00:30:17,320 --> 00:30:25,330
здесь, и вы возьмете

432
00:30:25,330 --> 00:30:32,385
идентификатор участника здесь, который является пользователями.

433
00:30:32,385 --> 00:30:36,320
Теперь на что ссылается этот пользователь?

434
00:30:36,320 --> 00:30:40,418
Эти пользователи ссылаются на это, что только что пришло.

435
00:30:40,418 --> 00:30:43,520
Поэтому, когда мы создавали этих пользователей,

436
00:30:43,520 --> 00:30:49,335
клиент должен создать успешный возврат к нам здесь.

437
00:30:49,335 --> 00:30:51,905
Так вот, что я собираюсь использовать здесь.

438
00:30:51,905 --> 00:30:53,240
Скажем, пользователи [0].

439
00:30:53,240 --> 00:30:58,430
Таким образом, это будет массив пользователей, которые были созданы и содержат только один из них.

440
00:30:58,430 --> 00:31:01,748
Поэтому я говорю, что пользователь [0].

441
00:31:01,748 --> 00:31:08,037
И тогда мы назначим ID этого пользователя здесь.

442
00:31:08,037 --> 00:31:14,215
Так мы создадим RoleMapping между ролью, которую мы только что создали,

443
00:31:14,215 --> 00:31:20,639
этой ролью, а затем сопоставим ее с клиентом, который мы только что создали.

444
00:31:20,639 --> 00:31:29,315
Теперь это также приводит нас к параметрам, функции обратного вызова.

445
00:31:29,315 --> 00:31:33,735
И в этой функции обратного вызова мы просто скажем,

446
00:31:33,735 --> 00:31:35,950
если (err) throw (err).

447
00:31:35,950 --> 00:31:41,825
В противном случае мы не очень заинтересованы в том, чтобы знать, что еще там произошло.

448
00:31:41,825 --> 00:31:44,055
Вот оно. Так вот как.

449
00:31:44,055 --> 00:31:46,870
Поэтому, если роль с именем admin не существует,

450
00:31:46,870 --> 00:31:48,819
мы создадим эту роль.

451
00:31:48,819 --> 00:31:53,785
Если нет - Так это

452
00:31:53,785 --> 00:32:01,170
часть «else», где мне все равно нужно будет сделать это сопоставление.

453
00:32:01,170 --> 00:32:08,140
Так что позвольте мне скопировать этот код, а затем я сделаю именно это здесь.

454
00:32:08,140 --> 00:32:15,834
Итак, role.principals.create, а затем сопоставить это для пользователя там.

455
00:32:15,834 --> 00:32:17,980
Поэтому, если роль администратора уже существует,

456
00:32:17,980 --> 00:32:20,730
тогда все, что им нужно сделать, это сопоставить.

457
00:32:20,730 --> 00:32:28,420
Таким образом, это будет сохранено в модели RoleMapping в нашей базе данных. Вот оно.

458
00:32:28,420 --> 00:32:34,520
Таким образом, этот фрагмент кода, который мы помещаем в файл script.js, сначала попытается

459
00:32:34,520 --> 00:32:41,765
найти, существует ли пользователь администратора, и этот пользователь идентифицируется именем admin.

460
00:32:41,765 --> 00:32:50,210
Если нет, то пользователь будет создан, а также затем создаст роль для пользователя.

461
00:32:50,210 --> 00:32:52,065
Мы создадим роль с именем admin.

462
00:32:52,065 --> 00:32:53,865
Если эта роль существует,

463
00:32:53,865 --> 00:32:54,950
мы просто используем ее.

464
00:32:54,950 --> 00:32:56,705
В противном случае мы создадим роль.

465
00:32:56,705 --> 00:33:01,485
И после этого мы создадим это сопоставление между ролью и пользователем.

466
00:33:01,485 --> 00:33:03,940
Таким образом, петля позволяет нам делать RoleMapping.

467
00:33:03,940 --> 00:33:07,310
Таким образом, говоря, этот пользователь не относится к этой роли.

468
00:33:07,310 --> 00:33:10,395
Таким образом, это сопоставление выполняется с помощью этого оператора.

469
00:33:10,395 --> 00:33:14,010
Таким образом, это завершает настройку наших серверов.

470
00:33:14,010 --> 00:33:18,305
Таким образом, пользователь администратора будет создан, и этот администратор

471
00:33:18,305 --> 00:33:24,155
автоматически получит роль администратора, как указано здесь.

472
00:33:24,155 --> 00:33:27,675
Вот оно. Давайте сохраним изменения в script.js.

473
00:33:27,675 --> 00:33:32,015
И теперь наши серверы замыкания на себя должны быть готовы.

474
00:33:32,015 --> 00:33:38,840
Итак, мы теперь пойдем и запустим наш сервер назад, а затем проверим, что мы можем сделать с этим.

475
00:33:38,840 --> 00:33:41,085
Перейдя к терминалам,

476
00:33:41,085 --> 00:33:43,060
давайте запустим сервер замыкания на себя.

477
00:33:43,060 --> 00:33:49,428
Так что скажем, npm start, а затем наш сервер должен быть запущен и запущен.

478
00:33:49,428 --> 00:33:53,220
Давайте перейдем к проводнику, а затем просмотрите информацию там.

479
00:33:53,220 --> 00:33:55,890
И этот сервер loopback автоматически

480
00:33:55,890 --> 00:33:59,535
подключается к моему MongoDP, потому что я установил соединение.

481
00:33:59,535 --> 00:34:03,415
Перейдя в мой браузер,

482
00:34:03,415 --> 00:34:05,610
позвольте мне перезагрузить это.

483
00:34:05,610 --> 00:34:07,879
И когда я перезагружу это,

484
00:34:07,879 --> 00:34:12,450
теперь вы увидите, что у нас есть новый клиент, который был создан здесь.

485
00:34:12,450 --> 00:34:14,705
Пользователь уже существовал ранее.

486
00:34:14,705 --> 00:34:17,840
Блюда, лидеры и акции все там.

487
00:34:17,840 --> 00:34:20,325
Давайте выполним залезание на посуду.

488
00:34:20,325 --> 00:34:23,250
Теперь, когда это связано с ртом MongoDB, у

489
00:34:23,250 --> 00:34:26,845
моего MongoDB уже есть некоторые блюда.

490
00:34:26,845 --> 00:34:28,235
Если ваш MongoDB пуст,

491
00:34:28,235 --> 00:34:31,821
вы можете опубликовать некоторые блюда, используя пост здесь.

492
00:34:31,821 --> 00:34:33,995
Так что давайте попробуем.

493
00:34:33,995 --> 00:34:38,040
Когда я сделаю операцию на блюдах слэша,

494
00:34:38,040 --> 00:34:42,945
вы увидите, что в теле ответа -

495
00:34:42,945 --> 00:34:48,090
все блюда, которые существуют в моей базе данных, были извлечены.

496
00:34:48,090 --> 00:34:52,995
Аналогично, я могу сделать GET по

497
00:34:52,995 --> 00:35:01,900
акциям, и я должен увидеть продвижение, которое уже существует в моей базе данных там.

498
00:35:01,900 --> 00:35:04,845
Таким образом, вы можете видеть, что продвижение уже существует там.

499
00:35:04,845 --> 00:35:09,978
Это показывает нам, как мы можем получить информацию.

500
00:35:09,978 --> 00:35:12,485
А теперь попробуем выложить новое блюдо.

501
00:35:12,485 --> 00:35:14,185
Итак, чтобы разместить новое блюдо,

502
00:35:14,185 --> 00:35:16,675
мы идем в POST здесь.

503
00:35:16,675 --> 00:35:18,715
Позволь мне просто скопировать это.

504
00:35:18,715 --> 00:35:20,035
Очевидно, в этот момент,

505
00:35:20,035 --> 00:35:22,080
потому что так как я не вошел в систему,

506
00:35:22,080 --> 00:35:26,180
мне не будет разрешено размещать блюдо так,

507
00:35:26,180 --> 00:35:31,615
но я продемонстрирую, что вам просто скопировать и вставить эту информацию здесь,

508
00:35:31,615 --> 00:35:34,120
и мы постараемся опубликовать это блюдо,

509
00:35:34,120 --> 00:35:36,010
а затем, когда я попытаюсь разместить блюдо,

510
00:35:36,010 --> 00:35:40,660
мой сервер немедленно отвечает с этой ошибкой, говоря: AUTRIZATION_REQUED.

511
00:35:40,660 --> 00:35:42,790
Вы не уполномочены выполнять эту операцию.

512
00:35:42,790 --> 00:35:46,146
Поэтому вы не уполномочены делать эту операцию.

513
00:35:46,146 --> 00:35:48,505
Итак, как вы разрешаете себя?

514
00:35:48,505 --> 00:35:50,315
Итак, чтобы авторизоваться,

515
00:35:50,315 --> 00:35:58,450
теперь вспомните, что мы уже создали одного пользователя с именем admin,

516
00:35:58,450 --> 00:36:05,240
и этот пользователь администратора уже существует как клиент здесь.

517
00:36:05,240 --> 00:36:11,495
Таким образом, войдя в конечные точки REST API клиента,

518
00:36:11,495 --> 00:36:12,835
если вы прокрутите

519
00:36:12,835 --> 00:36:16,925
вниз, ниже здесь, вы увидите вход этого клиента.

520
00:36:16,925 --> 00:36:20,220
Таким образом, когда вы выполняете POST при входе клиента.

521
00:36:20,220 --> 00:36:22,430
Таким образом, для входа клиента

522
00:36:22,430 --> 00:36:26,273
вы прокрутите здесь, а затем здесь он запрашивает учетные данные.

523
00:36:26,273 --> 00:36:27,540
Итак, в учетных данных

524
00:36:27,540 --> 00:36:35,190
мы можем ввести имя пользователя в двойные кавычки, и мы скажем,

525
00:36:35,190 --> 00:36:40,570
Admin, а затем пароль,

526
00:36:40,570 --> 00:36:48,665
мы скажем, пароль, и тогда мы опубликуем это.

527
00:36:48,665 --> 00:36:50,450
И тогда, когда вы его

528
00:36:50,450 --> 00:36:54,365
опубликуете, вы заметите, что в ответе

529
00:36:54,365 --> 00:36:57,764
LoopBack отправит мне эту информацию обратно.

530
00:36:57,764 --> 00:36:59,660
Теперь, в пределах этой информации,

531
00:36:59,660 --> 00:37:06,725
этот конкретный идентификатор, который он отправляет обратно, является AccessToken для моего сервера LoopBack.

532
00:37:06,725 --> 00:37:09,835
Итак, я могу просто скопировать этот AccessToken здесь,

533
00:37:09,835 --> 00:37:13,575
а затем прямо в верхней части здесь,

534
00:37:13,575 --> 00:37:17,735
вы можете видеть, что это Token Not Set, здесь.

535
00:37:17,735 --> 00:37:19,660
Там написано «Токен не установлен».

536
00:37:19,660 --> 00:37:22,415
И здесь вы можете ввести этот AccessToken,

537
00:37:22,415 --> 00:37:24,605
а затем сказать: «Установить токен доступа».

538
00:37:24,605 --> 00:37:27,245
И тогда ваш AccessToken будет установлен,

539
00:37:27,245 --> 00:37:33,525
а затем все последующие операции, которые вы выполняете, автоматически переносят

540
00:37:33,525 --> 00:37:39,750
этот AccessToken в заголовок моего сообщения запроса.

541
00:37:39,750 --> 00:37:45,350
Итак, таким образом, теперь моему администратору будет разрешено делать сообщения элементов там.

542
00:37:45,350 --> 00:37:47,480
Итак, теперь, когда я вошел в систему как администратор,

543
00:37:47,480 --> 00:37:49,135
позвольте мне перейти на акции,

544
00:37:49,135 --> 00:37:51,171
а затем я отправлю одну промо-акцию там

545
00:37:51,171 --> 00:37:57,098
и покажу вам, что я действительно могу размещать рекламные акции.

546
00:37:57,098 --> 00:38:00,885
Итак, давайте перейдем к POST,

547
00:38:00,885 --> 00:38:07,250
а затем мы просто скопируем это, а затем в данных,

548
00:38:07,250 --> 00:38:13,855
а затем для имени, которое мы скажем, Test promotion,

549
00:38:13,855 --> 00:38:24,500
и изображение мы просто оставим его как таковое, описание, Test Description.

550
00:38:30,990 --> 00:38:34,665
И я могу опубликовать его там,

551
00:38:34,665 --> 00:38:38,180
и вы увидите,

552
00:38:41,740 --> 00:38:48,265
что я не должен включать этот идентификатор здесь, потому что я

553
00:38:48,265 --> 00:38:53,710
позволил LoopBack автоматически назначить ему идентификатор.

554
00:38:53,710 --> 00:38:58,325
Позвольте мне опубликовать это, а затем вы увидите, что в теле ответа

555
00:38:58,325 --> 00:39:01,293
продвижение теста было опубликовано здесь.

556
00:39:01,293 --> 00:39:04,615
И я только что заметил, что я не включил

557
00:39:04,615 --> 00:39:11,130
флаг для моих промо-акций и моих лидеров.

558
00:39:11,130 --> 00:39:16,180
Итак, я собираюсь войти и включить флаг в качестве

559
00:39:16,180 --> 00:39:21,930
одной из частей моих акций там.

560
00:39:21,930 --> 00:39:26,845
Итак, теперь, когда я делаю GET для акций,

561
00:39:26,845 --> 00:39:29,875
вы увидите, что в этом ответном сообщении

562
00:39:29,875 --> 00:39:34,795
вы увидите старую акцию, которая уже была в моей базе данных,

563
00:39:34,795 --> 00:39:40,395
а затем новую акцию, которую я только что разместил в моей базе данных, уже включенной здесь.

564
00:39:40,395 --> 00:39:44,395
Итак, я только что заметил, что мне нужно установить флаг,

565
00:39:44,395 --> 00:39:46,695
я покажу вам, как это сделать в.

566
00:39:46,695 --> 00:39:54,100
Таким образом, этот вид демонстрирует вам, как вы можете войти в систему и исследовать ваш LoopBack сервер.

567
00:39:54,100 --> 00:39:55,420
Позвольте мне уничтожить этот токен,

568
00:39:55,420 --> 00:39:58,010
поэтому мы просто удалим токен,

569
00:39:58,010 --> 00:39:59,555
а затем нажмите на него,

570
00:39:59,555 --> 00:40:02,440
чтобы по существу отправить токен доступа в

571
00:40:02,440 --> 00:40:05,560
пустую строку, и поэтому мой токен больше не будет обрабатывать,

572
00:40:05,560 --> 00:40:07,880
поэтому теперь мой пользователь больше не входит в систему.

573
00:40:07,880 --> 00:40:11,148
Позвольте мне создать нового клиента.

574
00:40:11,148 --> 00:40:16,290
Итак, чтобы создать нового клиента я скажу, POST клиентов.

575
00:40:16,290 --> 00:40:20,780
А потом я просто скопирую это отсюда.

576
00:40:20,780 --> 00:40:24,175
Я создам себе новую учетную запись здесь.

577
00:40:24,175 --> 00:40:26,160
Итак, здесь

578
00:40:26,160 --> 00:40:28,620
я удалю область,

579
00:40:28,620 --> 00:40:32,186
мне это не нужно, мне не нужен идентификатор

580
00:40:32,186 --> 00:40:36,070
, поэтому для имени

581
00:40:39,750 --> 00:40:46,610
и EmailVerified должны автоматически устанавливаться системой.

582
00:40:46,610 --> 00:40:49,430
Итак, позвольте мне войти как этот пользователь.

583
00:40:49,430 --> 00:40:52,370
Итак, я просто собираюсь отправить свое имя, фамилию

584
00:40:52,370 --> 00:40:54,440
и изображение в настоящее время,

585
00:40:54,440 --> 00:40:59,745
я просто установлю там пустую строку, имя пользователя и email.

586
00:40:59,745 --> 00:41:01,835
И тогда мы попробуем его,

587
00:41:01,835 --> 00:41:05,060
а затем он возвращается, говоря: «

588
00:41:05,060 --> 00:41:08,820
Подробности»: «пароль» не может быть пустым.

589
00:41:08,820 --> 00:41:11,285
Итак, вы заметите, что здесь

590
00:41:11,285 --> 00:41:16,900
я также должен включить вместе с именем пользователя,

591
00:41:17,040 --> 00:41:27,834
паролем, а затем, давайте опубликуем это.

592
00:41:27,834 --> 00:41:30,890
Итак, когда вы его публикуете, он возвращается с

593
00:41:30,890 --> 00:41:35,535
телом ответа, говорящим, что вы теперь являетесь частью системы.

594
00:41:35,535 --> 00:41:37,160
Итак, ваше имя,

595
00:41:37,160 --> 00:41:40,280
ваша фамилия и ваше имя пользователя, ваш идентификатор электронной почты

596
00:41:40,280 --> 00:41:45,706
и идентификатор, который LoopBack назначает вам, отправляются вам обратно.

597
00:41:45,706 --> 00:41:52,777
Итак, это не что иное, как идентификатор MongoDB, как вы можете видеть здесь.

598
00:41:52,777 --> 00:41:56,150
Итак, теперь, когда я зарегистрировался как клиент,

599
00:41:56,150 --> 00:41:58,425
я должен иметь возможность войти в систему как клиент,

600
00:41:58,425 --> 00:42:01,775
так что я перейду в систему POST здесь,

601
00:42:01,775 --> 00:42:04,250
а затем здесь вместо администратора,

602
00:42:04,250 --> 00:42:11,710
я собираюсь войти в систему как новый пользователь, который я выполнил вход.

603
00:42:11,710 --> 00:42:14,130
Итак, затем я нажимаю, чтобы попробовать его,

604
00:42:14,130 --> 00:42:17,405
вы увидите, что он возвращается с идентификатором,

605
00:42:17,405 --> 00:42:22,910
поэтому он дает мне токен для этого пользователя администратора здесь.

606
00:42:22,910 --> 00:42:30,080
Таким образом, с этим мы завершили изучение сервера LoopBack, который мы только что создали.

607
00:42:30,080 --> 00:42:31,340
И как я только что упомянул,

608
00:42:31,340 --> 00:42:36,935
я заметил, что акции и лидеры не имеют флага, так что,

609
00:42:36,935 --> 00:42:40,930
я собираюсь войти в код.

610
00:42:40,930 --> 00:42:43,400
Итак, предположим, что вы забыли что-то подобное,

611
00:42:43,400 --> 00:42:47,305
тогда вы можете просто войти и отредактировать код Json, если хотите.

612
00:42:47,305 --> 00:42:50,540
Итак, я собираюсь войти в свой код, перейти

613
00:42:50,540 --> 00:42:52,040
к коду,

614
00:42:52,040 --> 00:42:56,635
я собираюсь сначала пойти в общее, а затем я пойду в dishes.json.

615
00:42:56,635 --> 00:42:59,750
И затем в dishes.json,

616
00:42:59,750 --> 00:43:05,320
я вижу это свойство признакам там.

617
00:43:05,320 --> 00:43:07,480
Я собираюсь скопировать это свойство,

618
00:43:07,480 --> 00:43:09,040
а затем я пойду в leaders.json,

619
00:43:09,040 --> 00:43:15,151
а затем я вставлю это свойство функции в leaders.json,

620
00:43:15,151 --> 00:43:17,750
а также с promotions.json.

621
00:43:17,750 --> 00:43:22,955
Я забыл включить это, когда создал эти модели.

622
00:43:22,955 --> 00:43:27,180
Я должен был сделать это, когда я создавал саму модель, поэтому,

623
00:43:27,180 --> 00:43:29,960
если вы забыли что-то подобное,

624
00:43:29,960 --> 00:43:33,370
то это еще один способ редактирования вашей модели,

625
00:43:33,370 --> 00:43:38,070
а затем убедиться, что ваша модель настроена правильно.

626
00:43:38,070 --> 00:43:40,130
Так вот и всё.

627
00:43:40,130 --> 00:43:48,575
Итак, теперь мои акции и лидеры также будут иметь флаг, установленный там.

628
00:43:48,575 --> 00:43:52,675
С этим мы завершаем это упражнение.

629
00:43:52,675 --> 00:43:56,525
В этом упражнении мы видели, как мы можем настроить

630
00:43:56,525 --> 00:44:03,555
новую модель путем расширения базового класса модели, который уже находится в LoopBack.

631
00:44:03,555 --> 00:44:07,250
Мы также видели, как можно настроить элементы управления доступом, используя

632
00:44:07,250 --> 00:44:11,540
списки контроля доступа, которые поддерживаются LoopBack.

633
00:44:11,540 --> 00:44:13,970
С этим мы завершаем это упражнение.

634
00:44:13,970 --> 00:44:16,835
Это хорошее время для вас, чтобы получить доступ к

635
00:44:16,835 --> 00:44:22,450
сообщениям LoopBack источников данных и контроля доступа.