1
00:00:03,710 --> 00:00:07,605
Теперь, когда мы узнали о Mongoose Population,

2
00:00:07,605 --> 00:00:14,040
и как это позволяет нам заполнить один документ информацией из другого документа.

3
00:00:14,040 --> 00:00:20,605
В этом упражнении мы изменим экспресс-сервер, над которым мы работали до сих пор.

4
00:00:20,605 --> 00:00:25,580
В схеме блюда, которую мы определили ранее, у нас были комментарии.

5
00:00:25,580 --> 00:00:28,365
Для комментариев у нас было поле автора

6
00:00:28,365 --> 00:00:31,490
, которое мы используем для хранения деталей об авторе.

7
00:00:31,490 --> 00:00:40,815
В этом упражнении мы превратим поле автора в ссылку на документ пользователя,

8
00:00:40,815 --> 00:00:46,265
и мы будем использовать Mongoose популяции, чтобы заполнить информацию

9
00:00:46,265 --> 00:00:50,330
в документ блюда по мере необходимости,

10
00:00:50,330 --> 00:00:54,440
чтобы предоставить информацию клиенту.

11
00:00:54,440 --> 00:00:59,960
Теперь использование популяции и мангуста должно быть сделано

12
00:00:59,960 --> 00:01:05,550
разумно, чтобы не вызывать слишком много накладных расходов на стороне сервера.

13
00:01:05,550 --> 00:01:06,890
Теперь в этом упражнении

14
00:01:06,890 --> 00:01:09,395
мы будем использовать его просто, чтобы заполнить информацию

15
00:01:09,395 --> 00:01:13,280
в поле автора наших комментариев.

16
00:01:13,280 --> 00:01:18,660
Итак, давайте продолжим упражнение, чтобы узнать, как мы используем популяцию Мангуста.

17
00:01:18,660 --> 00:01:21,455
Чтобы начать работу с этим упражнением,

18
00:01:21,455 --> 00:01:25,315
перейдите в проект и откройте файл user.js.

19
00:01:25,315 --> 00:01:27,730
Итак, в файле user.js

20
00:01:27,730 --> 00:01:29,600
мы храним пользовательскую схему.

21
00:01:29,600 --> 00:01:35,515
Я собираюсь изменить схему пользователя, добавив еще пару полей там.

22
00:01:35,515 --> 00:01:38,220
Одним из них является имя,

23
00:01:38,220 --> 00:01:40,070
которое будет

24
00:01:40,070 --> 00:01:48,115
строки типа и

25
00:01:48,115 --> 00:01:52,025
по умолчанию будет пустая строка.

26
00:01:52,025 --> 00:01:56,555
Итак, первое имя, как следует из имени,

27
00:01:56,555 --> 00:02:03,630
хранит имя для пользователя, а затем у нас будет другое поле, называемое фамилией,

28
00:02:03,630 --> 00:02:06,540
которое также имеет тот же вид.

29
00:02:06,540 --> 00:02:13,540
Итак, я просто собираюсь скопировать эти две части информации, а затем скопировать ее

30
00:02:13,540 --> 00:02:20,735
здесь и так теперь наш пользовательский документ будет содержать,

31
00:02:20,735 --> 00:02:22,840
в дополнение к имени пользователя и пароля, имя пользователя и

32
00:02:22,840 --> 00:02:26,760
тихо и соль, которые мы видели ранее,

33
00:02:26,760 --> 00:02:34,450
который автоматически добавляется паспортом локального модуля Mongoose .

34
00:02:34,450 --> 00:02:39,840
Мы также будем иметь имя и фамилию для пользователя, определяемого здесь.

35
00:02:39,840 --> 00:02:43,505
Позже мы увидим, как мы будем инициализировать

36
00:02:43,505 --> 00:02:50,765
эти значения путем изменения процесса регистрации пользователя.

37
00:02:50,765 --> 00:02:52,950
Теперь, как только мы завершили

38
00:02:52,950 --> 00:02:56,599
это, так что таким образом информацию пользователя

39
00:02:56,599 --> 00:03:00,880
можно просто получить, просматривая документ пользователя здесь.

40
00:03:00,880 --> 00:03:05,200
Итак, теперь, когда у нас есть информация о пользователе в пользовательском документе,

41
00:03:05,200 --> 00:03:08,560
идя в схему блюдо,

42
00:03:08,560 --> 00:03:11,015
поэтому перейдя в файл dishes.js.

43
00:03:11,015 --> 00:03:13,260
В схеме тарелки ранее

44
00:03:13,260 --> 00:03:18,465
мы хранили автора документа в виде строки здесь.

45
00:03:18,465 --> 00:03:22,700
Теперь мы будем использовать тот факт, что

46
00:03:22,700 --> 00:03:27,425
у нас есть поддержка популяции мангуста.

47
00:03:27,425 --> 00:03:33,740
Поэтому я собираюсь превратить поле комментария из строки в

48
00:03:33,740 --> 00:03:41,975
идентификатор объекта типа схемы мангуста.

49
00:03:41,975 --> 00:03:49,120
Итак, простите, неправильное поле.

50
00:03:49,120 --> 00:03:53,135
Я имел в виду превратить поле автора в

51
00:03:53,135 --> 00:04:02,295
идентификатор объекта типа схемы мангуста.

52
00:04:02,295 --> 00:04:05,390
Таким образом, поле автора теперь вместо хранения строки

53
00:04:05,390 --> 00:04:10,835
будет иметь ссылку на документ пользователя.

54
00:04:10,835 --> 00:04:14,105
Итак, когда я превращаю поле автора в этот тип,

55
00:04:14,105 --> 00:04:20,180
второе свойство, которое я определил здесь, будет ссылкой,

56
00:04:20,180 --> 00:04:25,229
которая будет ссылкой на пользовательскую модель.

57
00:04:25,229 --> 00:04:27,980
Таким образом, мы теперь будем

58
00:04:27,980 --> 00:04:31,370
соединять это поле автора, и это поле автора будет

59
00:04:31,370 --> 00:04:37,585
просто хранить ссылку на идентификатор документа пользователя,

60
00:04:37,585 --> 00:04:43,790
вместо того, чтобы хранить детали об авторе в виде имени.

61
00:04:43,790 --> 00:04:45,100
Теперь, когда мы это делаем,

62
00:04:45,100 --> 00:04:48,350
мы можем использовать mongoose populate, чтобы заполнить

63
00:04:48,350 --> 00:04:53,115
эту информацию в нашем документе блюд всякий раз, когда это необходимо.

64
00:04:53,115 --> 00:04:58,595
Таким образом, с этой модификацией схемы блюд, в файле dishes.js,

65
00:04:58,595 --> 00:05:05,910
мы теперь обновим маршрутизатор блюд, чтобы использовать популяцию мангуста.

66
00:05:05,910 --> 00:05:09,030
Итак, переходим к dishRouter.js.

67
00:05:09,030 --> 00:05:16,120
В блюдо роутер, вспомните, что когда мы получали блюдо здесь,

68
00:05:16,120 --> 00:05:19,470
теперь, когда вы получаете блюдо здесь,

69
00:05:19,470 --> 00:05:23,820
мы говорим, блюда найти тогда.

70
00:05:23,820 --> 00:05:26,610
Так что, прямо в этот момент,

71
00:05:26,610 --> 00:05:36,005
мы скажем, блюда найти и мы скажем после этого, заполнить.

72
00:05:36,005 --> 00:05:41,924
Итак, мы используем поддержку населения в мангусте,

73
00:05:41,924 --> 00:05:48,165
и мы скажем, заполнять комментарии автора.

74
00:05:48,165 --> 00:05:49,740
Таким образом, заявив это,

75
00:05:49,740 --> 00:05:51,060
мы говорим, когда

76
00:05:51,060 --> 00:05:58,750
документ блюд был построен, чтобы отправить ответ пользователю,

77
00:05:58,750 --> 00:06:05,810
мы собираемся заполнить поле автора внутри там из документа пользователя там.

78
00:06:05,810 --> 00:06:09,095
Таким образом, этот вызов заполнению гарантирует, что

79
00:06:09,095 --> 00:06:14,665
другое поле будет заполнено информацией по мере необходимости.

80
00:06:14,665 --> 00:06:18,565
Точно так же, идя на блюдо ID здесь,

81
00:06:18,565 --> 00:06:21,660
даже в блюдо ID, то же самое.

82
00:06:21,660 --> 00:06:31,680
Мы скажем, заполнение и комментарии автора добавлены

83
00:06:31,680 --> 00:06:37,320
в блюда найти по id

84
00:06:37,320 --> 00:06:43,395
в get конечной точки /dish ID.

85
00:06:43,395 --> 00:06:54,350
Аналогичным образом, в комментариях также, когда мы извлекаем блюдо,

86
00:06:54,520 --> 00:07:02,370
мы скажем, заполнить комментарии автора здесь и

87
00:07:02,370 --> 00:07:09,900
то же самое также в маршрутизаторе

88
00:07:09,900 --> 00:07:13,695
блюдо, комментарии идентификатор блюда, идентификатор комментария также.

89
00:07:13,695 --> 00:07:16,530
Чем больше заполняет эту информацию там.

90
00:07:16,530 --> 00:07:22,620
Теперь, конечно, это означает, что когда вы размещаете блюдо,

91
00:07:22,620 --> 00:07:30,090
раньше вы включаете информацию об авторе в текст сообщения.

92
00:07:30,090 --> 00:07:35,120
Итак, теперь здесь, когда мы пытаемся нажать комментарий в это,

93
00:07:35,120 --> 00:07:41,370
так что этот пост соответствует поле комментариев идентификатора блюда.

94
00:07:41,370 --> 00:07:46,280
Итак, вот как мы размещали комментарий к конкретному блюду.

95
00:07:46,280 --> 00:07:48,570
Итак, теперь в этом посте,

96
00:07:48,570 --> 00:07:53,890
так как мы больше не храним информацию об авторе,

97
00:07:53,890 --> 00:08:02,400
так что нам нужно сделать, это когда мы нажимаем элемент в поле автора там.

98
00:08:02,400 --> 00:08:06,720
Итак, здесь, когда вы заполняете информацию в блюдо,

99
00:08:06,720 --> 00:08:10,680
мы должны сначала

100
00:08:12,010 --> 00:08:16,430
напомнить, что тело содержит комментарий уже,

101
00:08:16,430 --> 00:08:21,505
но свойство автора не будет там в теле сообщения в книге,

102
00:08:21,505 --> 00:08:26,020
но в зависимости от того, какой пользователь публикует эту информацию,

103
00:08:26,020 --> 00:08:29,250
мы можем немедленно заполнить поле автора.

104
00:08:29,250 --> 00:08:32,535
Теперь, как мы узнаем, какой пользователь публикует эту информацию?

105
00:08:32,535 --> 00:08:38,165
Тот факт, что мы выполнили проверку пользователя здесь для сообщения,

106
00:08:38,165 --> 00:08:42,115
означает, что конкретный пользователь публикует эту информацию,

107
00:08:42,115 --> 00:08:44,250
и, выполняя проверку пользователя,

108
00:08:44,250 --> 00:08:50,415
мы бы уже загрузились в req.user в объект запроса.

109
00:08:50,415 --> 00:08:51,925
В объекте запроса

110
00:08:51,925 --> 00:08:55,565
мы можем войти и сказать user wreck,

111
00:08:55,565 --> 00:08:59,010
а затем подчеркнуть идентификатор здесь.

112
00:08:59,010 --> 00:09:01,910
Итак, позвольте мне еще раз повторить этот момент:

113
00:09:01,910 --> 00:09:05,760
как мы получаем здесь информацию автора?

114
00:09:05,760 --> 00:09:10,470
Теперь напомним, что мы обновили схему блюд,

115
00:09:10,470 --> 00:09:13,875
так что поле автора в комментарии просто сохранит

116
00:09:13,875 --> 00:09:20,915
идентификатор объекта, ссылающийся на пользователя, который публикует этот комментарий.

117
00:09:20,915 --> 00:09:24,450
Теперь, как мы узнаем, какой пользователь публикует этот комментарий?

118
00:09:24,450 --> 00:09:27,085
Теперь снова, чтобы повторить этот момент,

119
00:09:27,085 --> 00:09:31,825
напомним, что когда мы проверили пользователя здесь, вызвав пользователя аутентификации,

120
00:09:31,825 --> 00:09:37,590
авторизованный паспорт JWT загрузил бы

121
00:09:37,590 --> 00:09:45,120
информацию пользователя в тело запроса в виде req.user.

122
00:09:45,120 --> 00:09:48,470
Таким образом, этот пользователь будет содержать идентификатор

123
00:09:48,470 --> 00:09:52,520
конкретного пользователя, который фактически публикует этот комментарий.

124
00:09:52,520 --> 00:09:55,730
Таким образом, мы уже проверили подлинность пользователя,

125
00:09:55,730 --> 00:10:01,400
и поэтому идентификатор пользователя можно просто получить, сказав req.user.

126
00:10:01,400 --> 00:10:04,400
_ID, и идентификатор этого пользователя,

127
00:10:04,400 --> 00:10:09,380
я назначу это поле автора из комментария.

128
00:10:09,380 --> 00:10:10,990
Теперь, когда комментарий приходит,

129
00:10:10,990 --> 00:10:13,880
комментарий в теле сообщения запроса будет

130
00:10:13,880 --> 00:10:17,355
содержать только поле рейтинга и поле комментария.

131
00:10:17,355 --> 00:10:23,425
Теперь мы не хотим явно отправлять поле автора со стороны клиента,

132
00:10:23,425 --> 00:10:26,090
вместо этого это должно быть автоматически вставлено

133
00:10:26,090 --> 00:10:28,990
на стороне сервера на основе подлинности

134
00:10:28,990 --> 00:10:32,180
пользователя. Вот тот момент, который я

135
00:10:32,180 --> 00:10:36,830
повторял в этой модификации, что я сделал здесь.

136
00:10:36,830 --> 00:10:43,400
Таким образом, информация о пользователях автоматически получает от req.user, который

137
00:10:43,400 --> 00:10:50,200
загружается в тело сообщения запроса пользователем проверки подлинности,

138
00:10:50,200 --> 00:10:55,250
который будет использовать Passport authenticate со стратегией JWT там.

139
00:10:55,250 --> 00:10:59,795
Кроме того, теперь, когда мы получаем обновленное блюдо здесь,

140
00:10:59,795 --> 00:11:03,695
нам нужно заполнить авторскую информацию в блюдо.

141
00:11:03,695 --> 00:11:05,500
Итак, в этот момент,

142
00:11:05,500 --> 00:11:08,675
когда мы получаем блюдо здесь,

143
00:11:08,675 --> 00:11:15,370
мы будем искать блюда здесь.

144
00:11:15,370 --> 00:11:20,150
Итак, мы скажем Dishes.FindByID,

145
00:11:21,000 --> 00:11:28,090
а затем

146
00:11:28,090 --> 00:11:30,190
поставим идентификатор блюда в качестве параметра здесь, так что мы скажем, найти по

147
00:11:30,190 --> 00:11:33,175
ID, блюдо ID, а затем,

148
00:11:33,175 --> 00:11:43,405
нам нужно заполнить комментарии автора здесь,

149
00:11:43,405 --> 00:11:55,600
а затем мы скажем, блюдо.

150
00:11:55,600 --> 00:12:04,370
Внутри, мы отправим эту информацию о блюде пользователю здесь.

151
00:12:04,370 --> 00:12:07,260
Так что, позвольте мне вырезать это и вставить его сюда.

152
00:12:07,260 --> 00:12:12,670
Таким образом, эта модификация необходима, потому что теперь мне нужно заполнить

153
00:12:12,670 --> 00:12:15,190
информацию автора обратно

154
00:12:15,190 --> 00:12:18,760
в комментарий, прежде чем я смогу отправить текущее обратно пользователю.

155
00:12:18,760 --> 00:12:22,220
Итак, это дополнительная модификация, которую нам нужно

156
00:12:22,220 --> 00:12:26,105
сделать, когда мы используем популяцию Мангуста здесь.

157
00:12:26,105 --> 00:12:29,950
Точно так же, теперь идя в пут,

158
00:12:29,950 --> 00:12:34,450
когда мы изменяем конкретный комментарий с идентификатором комментария,

159
00:12:34,450 --> 00:12:40,830
так что это под блюдо ID комментариев части.

160
00:12:40,830 --> 00:12:42,890
Итак, когда мы делаем положить здесь,

161
00:12:42,890 --> 00:12:49,230
поэтому мы сначала находим блюда найти по id req params блюдо ID,

162
00:12:49,230 --> 00:12:50,840
затем в блюдо.

163
00:12:50,840 --> 00:12:57,160
Итак, первое, что мы проверяем, это убедиться, что если блюдо не является нулевым,

164
00:12:57,160 --> 00:13:01,430
а идентификатор комментариев блюда не равен нулю,

165
00:13:01,430 --> 00:13:08,665
поэтому мы проверили, чтобы убедиться, что комментарий действительно присутствует в блюде,

166
00:13:08,665 --> 00:13:12,320
а затем, когда само блюдо возвращается,

167
00:13:12,320 --> 00:13:16,385
то нам нужно снова искать

168
00:13:16,385 --> 00:13:21,230
блюдо, потому что нам нужно заполнить комментарии автора в блюдо.

169
00:13:21,230 --> 00:13:27,950
Итак, здесь мы скажем Dishes.FindByID (dish ID),

170
00:13:31,750 --> 00:13:36,880
причина, по которой нам нужно сделать еще один поиск, заключается в том, что

171
00:13:36,880 --> 00:13:42,240
нам нужно заполнить comments.author здесь,

172
00:13:42,240 --> 00:13:46,355
так что это единственная причина, почему нам нужно сделать еще один поиск здесь.

173
00:13:46,355 --> 00:13:50,720
Затем, когда мы получаем блюдо здесь,

174
00:13:52,260 --> 00:14:03,640
очевидно, потому что мы только что обновили блюдо, так что информация о блюде должна быть

175
00:14:03,640 --> 00:14:07,490
найдена в базе данных, так что должны работать нормально, а затем внутри будет говорить

176
00:14:07,490 --> 00:14:12,215
код риска 200 res установить заголовок типа приложения json,

177
00:14:12,215 --> 00:14:14,960
а затем вернуть блюдо здесь,

178
00:14:14,960 --> 00:14:16,740
а затем мы будем обрабатывать ошибку здесь,

179
00:14:16,740 --> 00:14:19,630
а затем другие, если блюда

180
00:14:19,630 --> 00:14:24,095
сейчас, а также другие ошибки, которые мы установили ранее,

181
00:14:24,095 --> 00:14:27,050
они будут обрабатываться как обычно здесь.

182
00:14:27,050 --> 00:14:32,790
Итак, это дополнительные изменения, которые мы должны убедиться, когда вы обновите блюдо,

183
00:14:32,790 --> 00:14:39,175
когда вы отправляете обратно обновленный комментарий или обновленное блюдо,

184
00:14:39,175 --> 00:14:44,485
то мы заполним комментарий в блюдо здесь.

185
00:14:44,485 --> 00:14:48,160
Аналогичным образом, перейдя к

186
00:14:48,160 --> 00:14:50,575
удалению здесь, а затем после удаления комментария,

187
00:14:50,575 --> 00:14:59,310
снова мы собираемся получить блюдо и заполнить информацию автора.

188
00:14:59,310 --> 00:15:01,275
Итак, позвольте мне просто скопировать эту часть,

189
00:15:01,275 --> 00:15:04,130
а затем мы будем делать точно то же самое здесь,

190
00:15:04,130 --> 00:15:06,770
поэтому мы скажем блюдо сохранить,

191
00:15:06,770 --> 00:15:16,210
затем мы будем проверять Dish.FindByID (автор блюда),

192
00:15:16,210 --> 00:15:19,760
а затем мы заполним автора комментариев,

193
00:15:19,760 --> 00:15:21,925
а затем мы скажем (затем) блюдо,

194
00:15:21,925 --> 00:15:24,920
а затем res.StatusCode, и так далее,

195
00:15:24,920 --> 00:15:29,350
а оставшаяся обработка ошибок, как и прежде.

196
00:15:29,350 --> 00:15:33,040
Итак, с этой модификацией в блюдо роутер,

197
00:15:33,040 --> 00:15:41,420
теперь последний момент, который мы должны учитывать, это тот факт, что в файле user.js

198
00:15:41,420 --> 00:15:43,740
мы теперь добавили в поля

199
00:15:43,740 --> 00:15:49,050
имя и фамилию поля, которые по умолчанию будут пустыми строками.

200
00:15:49,050 --> 00:15:51,880
Таким образом, когда пользователь регистрируется,

201
00:15:51,880 --> 00:15:54,670
мы должны позволить пользователю указать имя и

202
00:15:54,670 --> 00:15:58,040
фамилию в процессе регистрации.

203
00:15:58,040 --> 00:16:00,040
Теперь, где это происходит?

204
00:16:00,040 --> 00:16:03,025
Это происходит в пользователей.js.

205
00:16:03,025 --> 00:16:05,390
Итак, перейдя к пользователям users.js,

206
00:16:05,390 --> 00:16:09,885
когда пользователь публикует на рассылке косой черты,

207
00:16:09,885 --> 00:16:13,050
ранее мы только размещали имя пользователя и пароль.

208
00:16:13,050 --> 00:16:15,105
В дополнение к этим двум,

209
00:16:15,105 --> 00:16:21,785
в объекте json, который мы включаем в тело сообщения запроса, поступающего в

210
00:16:21,785 --> 00:16:25,530
сообщение с запросом, поступающее со стороны клиента,

211
00:16:25,530 --> 00:16:29,590
мы также можем включить имя и фамилию пользователя.

212
00:16:29,590 --> 00:16:33,740
Итак, когда имя и фамилия пользователя включены,

213
00:16:33,740 --> 00:16:35,590
так что мне здесь делать?

214
00:16:35,590 --> 00:16:42,450
Итак, помните, что когда вы говорите user.register в этот момент, информация о пользователе приходит,

215
00:16:42,450 --> 00:16:45,785
а затем вы отправили имя пользователя здесь,

216
00:16:45,785 --> 00:16:49,460
и вы также назначили пароль здесь, который будет

217
00:16:49,460 --> 00:16:53,380
превращен в хэш и соль паспортом локального мангуста.

218
00:16:53,380 --> 00:17:00,000
Теперь, если нет ошибки, это означает, что регистрация пользователя была успешной,

219
00:17:00,000 --> 00:17:08,740
и поэтому в этот момент мы будем делать, мы скажем, если req.body.

220
00:17:08,740 --> 00:17:13,420
Имя. Итак, что означает, что тело входящего сообщения запроса,

221
00:17:13,420 --> 00:17:16,345
если оно содержит имя,

222
00:17:16,345 --> 00:17:24,770
то мы скажем user.firstname равно req.body.firstname.

223
00:17:26,160 --> 00:17:29,675
Аналогично, для фамилии также.

224
00:17:29,675 --> 00:17:32,040
Таким образом, на данный момент

225
00:17:32,040 --> 00:17:34,780
у нас будет пользователь, доступный здесь.

226
00:17:34,780 --> 00:17:40,125
См. Пользователь входит в качестве второго параметра этой функции обратного вызова здесь.

227
00:17:40,125 --> 00:17:43,455
Итак, мы настраиваем имя, изменяя

228
00:17:43,455 --> 00:17:51,490
свойство первого имени внутри пользовательского документа здесь, говоря: req.body.firstname.

229
00:17:51,490 --> 00:17:55,395
Если он существует, то мы установим имя пользователя на это.

230
00:17:55,395 --> 00:18:03,220
Аналогично, если доступно имя req.body.flaw,

231
00:18:03,220 --> 00:18:09,630
поэтому мы также обновим фамилию пользователя как req.body.lastname.

232
00:18:09,770 --> 00:18:16,650
И как только мы сделали эти два изменения в имя и фамилию,

233
00:18:16,650 --> 00:18:23,160
то нам нужно сохранить изменения, которые мы сделали для пользователя.

234
00:18:23,160 --> 00:18:25,030
Итак, мы только что обновили пользователя.

235
00:18:25,030 --> 00:18:30,550
Итак, мы скажем user.save, тогда это

236
00:18:30,550 --> 00:18:37,190
вернет ошибку или пользователя.

237
00:18:37,190 --> 00:18:41,025
Итак, если модификация была сохранена правильно,

238
00:18:41,025 --> 00:18:43,765
то она вернет ошибку,

239
00:18:43,765 --> 00:18:49,380
иначе она вернет значение пользователя и этот паспорт аутентифицировать мы

240
00:18:49,380 --> 00:18:55,710
сделаем это внутри этого пользователя здесь.

241
00:18:55,710 --> 00:19:00,505
Итак, скажем, user.save (err, user).

242
00:19:00,505 --> 00:19:04,740
А затем нам также нужно перепроверить, чтобы убедиться, что

243
00:19:04,740 --> 00:19:10,660
если есть ошибка в сохранении изменений пользователю,

244
00:19:10,660 --> 00:19:15,180
то мы скажем res код состояния 500,

245
00:19:15,180 --> 00:19:18,485
поэтому позвольте мне скопировать это оттуда.

246
00:19:18,485 --> 00:19:23,275
Итак, мы скажем код статуса res 500,

247
00:19:23,275 --> 00:19:30,220
res устанавливает тип содержимого заголовка приложения json и res.jason здесь.

248
00:19:30,220 --> 00:19:35,995
Тогда, и мы вернемся к этому моменту.

249
00:19:35,995 --> 00:19:37,960
Если ошибки нет,

250
00:19:37,960 --> 00:19:40,480
то, конечно, вы аутентифицируете пользователя, вызвав

251
00:19:40,480 --> 00:19:43,550
паспорт аутентифицироваться с локальным, чтобы убедиться, что

252
00:19:43,550 --> 00:19:48,835
регистрация пользователя прошла успешно, и это должно быть

253
00:19:48,835 --> 00:19:56,390
сделано правильно, и в этом случае вы вернете это сообщение обратно на стороне клиента.

254
00:19:56,390 --> 00:20:03,215
Нам нужно закрыть этот user.save здесь.

255
00:20:03,215 --> 00:20:07,520
Таким образом, убедитесь, что вы правильно закрыли эту конечную точку.

256
00:20:07,520 --> 00:20:11,005
Итак, user.save закрыт здесь, и все.

257
00:20:11,005 --> 00:20:14,730
Это изменения, которые нам нужно внести для пользователя.

258
00:20:14,730 --> 00:20:21,740
Таким образом, после того, как пользователь зарегистрирован с данным именем пользователя и данным паролем,

259
00:20:21,740 --> 00:20:24,940
затем после того, как пользователь успешно зарегистрирован,

260
00:20:24,940 --> 00:20:28,235
то мы установим поле

261
00:20:28,235 --> 00:20:32,925
имени и фамилии документа пользователя, используя эти два здесь.

262
00:20:32,925 --> 00:20:35,900
Мы хотим убедиться, что пользователь успешно

263
00:20:35,900 --> 00:20:39,160
зарегистрирован перед отправкой имени и фамилии для этого.

264
00:20:39,160 --> 00:20:42,540
Поэтому мы проводим эту операцию после

265
00:20:42,540 --> 00:20:46,360
успешной регистрации пользователя. Вот оно.

266
00:20:46,360 --> 00:20:53,785
Давайте сохраним изменения и пойдем и проверим сервер.

267
00:20:53,785 --> 00:20:56,185
После сохранения изменений

268
00:20:56,185 --> 00:20:59,980
давайте теперь перейдем к терминалу, а

269
00:20:59,980 --> 00:21:06,925
затем, прежде чем я запускаю сервер,

270
00:21:06,925 --> 00:21:16,690
позвольте мне сначала проверить мой MongoDB и удалить пользователя, который мы зарегистрировали ранее.

271
00:21:16,690 --> 00:21:25,640
Итак, мы скажем, используйте путаницу, а затем мы скажем db.usersfind.

272
00:21:25,650 --> 00:21:30,690
Таким образом, мы знаем, что этот конкретный пользователь был зарегистрирован ранее,

273
00:21:30,690 --> 00:21:32,580
но когда

274
00:21:32,580 --> 00:21:35,700
мы регистрируем этого пользователя, мы не регистрировали имя и фамилию пользователя.

275
00:21:35,700 --> 00:21:39,155
Итак, я собираюсь удалить этого пользователя, а затем повторно зарегистрировать пользователя.

276
00:21:39,155 --> 00:21:48,370
Итак, чтобы сделать это с помощью пульсации Mongo, я скажу, что пользователи db падают,

277
00:21:48,370 --> 00:21:52,220
а затем мы скажем,

278
00:21:52,220 --> 00:21:54,620
что пользователи db находят, и это должно вернуть пустой.

279
00:21:54,620 --> 00:22:01,685
Там нет пользователей, и тогда мы выйдем из пульсации Монго.

280
00:22:01,685 --> 00:22:05,285
Итак, как только мы удалили этого зарегистрированного пользователя

281
00:22:05,285 --> 00:22:08,760
, позвольте мне запустить свой сервер.

282
00:22:09,490 --> 00:22:12,275
И как только сервер будет запущен,

283
00:22:12,275 --> 00:22:16,240
давайте перейдем к Почтальону, а затем зарегистрируем

284
00:22:16,240 --> 00:22:20,930
нового пользователя вместе с именем и фамилией пользователя.

285
00:22:20,930 --> 00:22:26,845
Затем, они войдут в качестве этого пользователя, а затем мы посмотрим, как

286
00:22:26,845 --> 00:22:31,650
население Mongoose помогает нам заполнить информацию

287
00:22:31,650 --> 00:22:37,000
о пользователе автоматически в документ там.

288
00:22:37,000 --> 00:22:40,029
Теперь, перейдя в

289
00:22:40,029 --> 00:22:42,660
почтальон, позвольте мне зарегистрироваться нового пользователя.

290
00:22:42,660 --> 00:22:48,310
Итак, я делаю сообщение localhost: 3000 пользователей регистрируются.

291
00:22:48,310 --> 00:22:50,715
В теле сообщения

292
00:22:50,715 --> 00:22:54,910
у нас было имя пользователя и пароль уже там.

293
00:22:54,910 --> 00:22:59,199
Позвольте мне добавить два дополнительных поля:

294
00:22:59,199 --> 00:23:09,350
имя, фамилия.

295
00:23:14,880 --> 00:23:18,530
Затем зарегистрируйте этого пользователя.

296
00:23:20,850 --> 00:23:23,680
Итак, как только я зарегистрирую пользователя,

297
00:23:23,680 --> 00:23:26,350
вы увидите, что регистрация прошла успешно.

298
00:23:26,350 --> 00:23:29,810
Теперь позвольте мне войти в систему как этот пользователь.

299
00:23:29,820 --> 00:23:32,640
Итак, чтобы войти в систему как пользователь,

300
00:23:32,640 --> 00:23:37,620
позвольте мне сделать сообщение и перекрестную проверку, чтобы убедиться.

301
00:23:37,620 --> 00:23:40,475
Итак, я делаю сообщение для входа пользователей.

302
00:23:40,475 --> 00:23:45,725
Позвольте мне проверить, и я вижу, что имя пользователя и пароль правильно введены там.

303
00:23:45,725 --> 00:23:47,775
Поэтому, когда я вхожу в систему,

304
00:23:47,775 --> 00:23:53,165
я должен быть успешно зарегистрирован, и я должен иметь возможность получить этот токен там.

305
00:23:53,165 --> 00:24:02,660
Потому что этот токен имеет важное значение для нас, чтобы иметь возможность добавить блюдо на наш сайт сервера.

306
00:24:02,660 --> 00:24:05,915
Итак, после того, как вы получите токен,

307
00:24:05,915 --> 00:24:10,250
скопируйте эту строку токена и сохраните ее, потому что вам понадобится это в

308
00:24:10,250 --> 00:24:13,220
заголовке авторизации для

309
00:24:13,220 --> 00:24:16,910
операций post put и delete, которые вы собираетесь выполнить позже.

310
00:24:16,910 --> 00:24:20,540
Так что позвольте мне скопировать этот жетон.

311
00:24:20,540 --> 00:24:23,890
Теперь, как правило, я бы сохранил эти токены

312
00:24:23,890 --> 00:24:28,400
, я просто открою текстовый документ, а затем скопирую и вставьте его в текстовый документ.

313
00:24:28,400 --> 00:24:31,190
Таким образом, для последующих запросов почтальона

314
00:24:31,190 --> 00:24:34,230
я могу просто скопировать эту строку, а затем вставить ее

315
00:24:34,230 --> 00:24:37,770
в заголовок авторизации, если это необходимо.

316
00:24:37,770 --> 00:24:44,070
Итак, позвольте мне скопировать этот токен, и здесь у меня есть текстовый документ, открытый здесь.

317
00:24:44,070 --> 00:24:50,815
Итак, я собираюсь вставить эту строку в этот текстовый документ.

318
00:24:50,815 --> 00:24:57,170
Итак, здесь у нас есть токен, который мы получили.

319
00:24:57,170 --> 00:25:03,120
Давайте теперь пойдем и разместим блюдо на нашем сервере.

320
00:25:03,120 --> 00:25:05,135
Возвращаясь к почтальну,

321
00:25:05,135 --> 00:25:07,535
позвольте мне отправить блюдо на сервер.

322
00:25:07,535 --> 00:25:12,690
Итак, вот где я выберу пост здесь.

323
00:25:12,690 --> 00:25:21,334
Внутри здесь у меня есть информация о блюде, которую я использовал ранее, но для комментариев,

324
00:25:21,334 --> 00:25:25,345
теперь, напомним, что ранее у нас было поле автора, которое хранило строку.

325
00:25:25,345 --> 00:25:28,770
Таким образом, все эти комментарии недействительны.

326
00:25:28,770 --> 00:25:35,110
Итак, я собираюсь удалить все эти комментарии из представления, потому что

327
00:25:35,110 --> 00:25:42,570
теперь мы ожидаем, что пользователь будет публиковать комментарии самостоятельно.

328
00:25:42,570 --> 00:25:44,460
Когда пользователь отправляет комментарии,

329
00:25:44,460 --> 00:25:52,155
мы автоматически добавим идентификатор пользователя в поле автора комментариев.

330
00:25:52,155 --> 00:25:55,390
Итак, позвольте мне разместить это блюдо здесь.

331
00:25:55,390 --> 00:25:57,325
Перейдя к заголовку,

332
00:25:57,325 --> 00:26:01,550
в заголовке авторизации, я собираюсь сказать, на

333
00:26:02,310 --> 00:26:12,785
носителя, а затем вставить токен, а затем отправить.

334
00:26:12,785 --> 00:26:17,055
Я должен сделать сообщение об этом.

335
00:26:17,055 --> 00:26:21,950
Итак, я скажу сообщение, и поэтому, когда я отправлю сейчас,

336
00:26:21,950 --> 00:26:26,785
вы видите, что это блюдо было опубликовано на стороне сервера,

337
00:26:26,785 --> 00:26:31,340
и массив комментариев в данный момент пуст.

338
00:26:31,340 --> 00:26:34,450
Итак, после того, как я отправлю это блюдо,

339
00:26:34,450 --> 00:26:37,660
позвольте мне скопировать идентификатор этого блюда.

340
00:26:37,660 --> 00:26:40,835
Итак, позвольте мне скопировать этот идентификатор для блюда, потому что мне

341
00:26:40,835 --> 00:26:44,735
нужно, чтобы оставить комментарии к этому блюду.

342
00:26:44,735 --> 00:26:47,075
Затем, перейдя в текстовый редактор,

343
00:26:47,075 --> 00:26:51,485
я собираюсь сохранить этот идентификатор блюда здесь.

344
00:26:51,485 --> 00:26:54,550
Теперь, конечно, как только вы создаете свою клиентскую сторону,

345
00:26:54,550 --> 00:26:57,770
ваш клиент автоматически получит всю эту информацию.

346
00:26:57,770 --> 00:27:02,565
Таким образом, ваш клиент автоматически сможет отправить токен и так далее.

347
00:27:02,565 --> 00:27:06,385
Так что вам не нужно делать эту штуку, но с почтальоном

348
00:27:06,385 --> 00:27:11,750
это единственный способ добавить любую информацию в наши запросы почтальона,

349
00:27:11,750 --> 00:27:17,185
которая отправляется от почтальона на сервер.

350
00:27:17,185 --> 00:27:22,090
Теперь, чтобы убедить себя в том, что это блюдо действительно существует,

351
00:27:22,090 --> 00:27:26,310
позвольте мне получить на местный хозяин: 3000/блюда.

352
00:27:26,570 --> 00:27:30,750
Когда я делаю get, вы можете увидеть, что

353
00:27:30,750 --> 00:27:34,175
это конкретное блюдо существует на стороне сервера.

354
00:27:34,175 --> 00:27:37,600
Итак, давайте теперь попробуем оставить комментарий.

355
00:27:37,600 --> 00:27:39,515
Итак, чтобы опубликовать комментарий,

356
00:27:39,515 --> 00:27:45,550
давайте сделаем сообщение, и мы скажем,

357
00:27:49,940 --> 00:27:54,950
localhost: 3000/блюда, косая черта и идентификатор блюда, которое

358
00:27:54,950 --> 00:27:59,910
я только что скопировал, и косая черта комментарии.

359
00:27:59,910 --> 00:28:03,090
Когда вы размещаете на комментариях,

360
00:28:03,090 --> 00:28:11,285
вам нужно убедиться, что в теле мы добавим в комментарий здесь.

361
00:28:11,285 --> 00:28:13,605
Итак, типичный комментарий содержит

362
00:28:13,605 --> 00:28:20,555
оценку, скажем,

363
00:28:20,555 --> 00:28:26,140
пять, а затем комментарий.

364
00:28:29,030 --> 00:28:33,535
Итак, позвольте мне просто ввести какой-то случайный комментарий,

365
00:28:33,535 --> 00:28:34,915
просто чтобы продемонстрировать вам.

366
00:28:34,915 --> 00:28:41,085
Таким образом, это должно быть в теле сообщения для комментариев и в заголовке,

367
00:28:41,085 --> 00:28:44,665
мы должны добавить заголовок авторизации.

368
00:28:44,665 --> 00:28:50,525
Итак, для заголовка авторизации, скажем, носитель.

369
00:28:50,525 --> 00:28:54,875
Мне нужно вставить токен здесь,

370
00:28:54,875 --> 00:28:59,065
вставив значение токена, которое я сохранил ранее.

371
00:28:59,065 --> 00:29:02,575
Давайте теперь оставим этот комментарий.

372
00:29:02,575 --> 00:29:05,265
Затем, когда комментарий опубликован,

373
00:29:05,265 --> 00:29:07,705
давайте посмотрим на возвращаемое значение здесь.

374
00:29:07,705 --> 00:29:09,510
Таким образом, когда вы просматриваете вниз,

375
00:29:09,510 --> 00:29:14,975
вы можете увидеть, что блюдо, к которому был добавлен комментарий, было возвращено.

376
00:29:14,975 --> 00:29:19,300
Обратите внимание, что информация о блюде есть, но обратите внимание, в частности,

377
00:29:19,300 --> 00:29:22,620
что содержится в комментарии, который был опубликован здесь.

378
00:29:22,620 --> 00:29:25,740
Таким образом, как вы можете видеть, вы уже знаете, что обновленные и

379
00:29:25,740 --> 00:29:29,050
созданные в полях автоматически добавляются mongoose.

380
00:29:29,050 --> 00:29:31,900
Рейтинг и комментарий, который мы представили, находятся

381
00:29:31,900 --> 00:29:34,780
прямо там, но обратите внимание, как поле автора

382
00:29:34,780 --> 00:29:40,675
теперь содержит идентификатор, соответствующий пользователю.

383
00:29:40,675 --> 00:29:47,190
Теперь, как мы видели в коде, как добавляется информация о поле автора, теперь,

384
00:29:47,190 --> 00:29:49,965
если вы сделаете попадание на блюда,

385
00:29:49,965 --> 00:29:52,900
вы заметите, что это поле автора будет

386
00:29:52,900 --> 00:29:56,890
автоматически заполнено информацией пользователей здесь.

387
00:29:56,890 --> 00:30:02,180
Итак, давайте теперь сделаем get на локальном хосте: 3000/блюда.

388
00:30:02,300 --> 00:30:06,820
Итак, когда мы сейчас делаем на этот момент,

389
00:30:06,820 --> 00:30:12,215
вы заметите, что в блюдах здесь,

390
00:30:12,215 --> 00:30:15,460
прямо там, информация о блюде уже

391
00:30:15,460 --> 00:30:20,110
присутствует, но обратите внимание, как комментарий теперь построен.

392
00:30:20,110 --> 00:30:23,500
Комментарий теперь содержит,

393
00:30:23,500 --> 00:30:27,240
поля рейтинга комментария, как мы видели ранее,

394
00:30:27,240 --> 00:30:28,780
обновленные и созданные на,

395
00:30:28,780 --> 00:30:32,910
но обратите внимание, что произошло с полем автора здесь.

396
00:30:32,910 --> 00:30:36,890
Таким образом, когда вы делаете запрос get, потому что мы сделали заполнение на

397
00:30:36,890 --> 00:30:42,230
стороне сервера при вызове операции get,

398
00:30:42,230 --> 00:30:45,750
заполнение автоматически заполняет

399
00:30:45,750 --> 00:30:51,390
информацию автора в позицию в поле автора здесь.

400
00:30:51,390 --> 00:30:54,215
Таким образом, там вы можете видеть, что от автора

401
00:30:54,215 --> 00:30:56,260
теперь вы можете искать фамилию и

402
00:30:56,260 --> 00:30:58,970
имя информацию автоматически из поля автора.

403
00:30:58,970 --> 00:31:01,645
Итак, если вам нужно построить комментарий,

404
00:31:01,645 --> 00:31:04,050
то теперь у вас есть рейтинг

405
00:31:04,050 --> 00:31:08,210
, комментарий, а также имя и фамилия

406
00:31:08,210 --> 00:31:12,485
автора автоматически включаются в этот документ.

407
00:31:12,485 --> 00:31:15,645
Кроме того, имя пользователя также включено в этот документ.

408
00:31:15,645 --> 00:31:21,495
Таким образом, вы можете добавить информацию из другого документа и заполнить

409
00:31:21,495 --> 00:31:27,905
второй документ этой информацией, прежде чем отвечать с сайта сервера.

410
00:31:27,905 --> 00:31:32,315
Таким образом, это использование популяции мангуста и как мы

411
00:31:32,315 --> 00:31:37,580
можем автоматически заполнить информацию в документ мангуста.

412
00:31:37,580 --> 00:31:41,280
С этим мы завершаем это упражнение.

413
00:31:41,280 --> 00:31:46,075
В этом упражнении мы видели использование популяции мангуста, и мы также видели,

414
00:31:46,075 --> 00:31:51,785
как мы можем заполнить информацию из одного документа в другой документ. Таким образом

415
00:31:51,785 --> 00:31:57,340
, когда мы модифицируем сервер, чтобы сделать население для запросов,

416
00:31:57,340 --> 00:32:02,200
mangoose автоматически позаботится о заполнении этой информации для нас.

417
00:32:02,200 --> 00:32:04,190
Все, что нам нужно сделать,

418
00:32:04,190 --> 00:32:10,900
это сохранить ссылку на другой документ в виде идентификатора объекта,

419
00:32:10,900 --> 00:32:16,240
в документ, в который вы хотите заполнить эту информацию.

420
00:32:16,240 --> 00:32:18,965
С этим мы завершаем это упражнение.

421
00:32:18,965 --> 00:32:25,230
Это хорошее время для вас сделать git-commit с сообщением, популяцией мангуста.