1
00:00:03,920 --> 00:00:09,645
Как мы поняли из предыдущей лекции в этом уроке,

2
00:00:09,645 --> 00:00:12,585
наша цель в этом уроке -

3
00:00:12,585 --> 00:00:16,590
интегрировать уже разработанный нами REST API сервер

4
00:00:16,590 --> 00:00:20,525
вместе с доступом к базе данных MongoDB.

5
00:00:20,525 --> 00:00:24,060
Итак, мы начнем с сервера REST API,

6
00:00:24,060 --> 00:00:27,480
который мы построили в самом первом уроке в этом модуле,

7
00:00:27,480 --> 00:00:31,770
а затем научившись взаимодействовать с

8
00:00:31,770 --> 00:00:37,220
нашим узловым приложением на сервер Mongoose с помощью Mongoose,

9
00:00:37,220 --> 00:00:43,865
мы будем развивать наш REST API сервер для интеграции

10
00:00:43,865 --> 00:00:50,749
всего путь между запросом клиента, поступающим на сервер,

11
00:00:50,749 --> 00:00:53,840
вплоть до соответствующей операции базы данных, которая должна быть выполнена,

12
00:00:53,840 --> 00:01:00,880
а затем построение и отправка ответа этому клиенту с нашего сайта сервера.

13
00:01:00,880 --> 00:01:04,125
Чтобы начать, конечно, сначала

14
00:01:04,125 --> 00:01:08,300
перейдите в папку сервера путаницы, которую мы уже создали в

15
00:01:08,300 --> 00:01:15,215
самом первом упражнении этого модуля в уроке REST API,

16
00:01:15,215 --> 00:01:17,915
а затем, в папке путаницы,

17
00:01:17,915 --> 00:01:22,310
мы уже создали сервер REST API.

18
00:01:22,310 --> 00:01:26,630
Теперь, что мы будем делать, это заимствовать

19
00:01:26,630 --> 00:01:32,035
модели, которые мы разработали в предыдущем упражнении,

20
00:01:32,035 --> 00:01:36,050
файл dishes.js, который мы разработали в предыдущем упражнении,

21
00:01:36,050 --> 00:01:41,220
скопированный в проект сервера путаницы,

22
00:01:41,220 --> 00:01:44,430
а также установить Bluebird Mongoose

23
00:01:44,430 --> 00:01:51,225
и другой модуль под названием Mongoose валюту, в наш проект.

24
00:01:51,225 --> 00:01:54,275
Итак, перейдя к нашей папке JS узла,

25
00:01:54,275 --> 00:01:57,050
мы сначала идем в папку узла Mongoose,

26
00:01:57,050 --> 00:02:01,970
и мы видим, что в подпапке моделей папки узла Mongoose,

27
00:02:01,970 --> 00:02:03,810
у нас есть файл dishes.js.

28
00:02:03,810 --> 00:02:07,354
Я просто скопирую папку моделей,

29
00:02:07,354 --> 00:02:10,490
а затем перейду в папку сервера путаницы,

30
00:02:10,490 --> 00:02:13,910
а затем просто пронзим папку моделей там.

31
00:02:13,910 --> 00:02:15,690
Итак, как только мы это сделаем,

32
00:02:15,690 --> 00:02:22,540
то файл dishes.js, который содержит схему и модель документа посуды,

33
00:02:22,540 --> 00:02:28,155
интегрируется в наш REST API сервер.

34
00:02:28,155 --> 00:02:30,890
Конечно, для того, чтобы использовать это,

35
00:02:30,890 --> 00:02:34,400
нам нужно установить модуль узла Mongoose

36
00:02:34,400 --> 00:02:40,990
и новый модуль узла под названием Mongoose валюты в наш проект.

37
00:02:40,990 --> 00:02:47,510
Итак, перейдя на терминал в проекте сервера путаницы,

38
00:02:47,510 --> 00:02:52,640
убедитесь, что ваш терминал или командное окно находится

39
00:02:52,640 --> 00:02:57,480
в проекте сервера путаницы, где вы разрабатываете REST API раньше,

40
00:02:57,480 --> 00:03:01,070
и в этом проекте давайте установим.

41
00:03:01,070 --> 00:03:06,165
Итак, мы сделаем npm установить Mongoose,

42
00:03:06,165 --> 00:03:13,110
а затем, новый модуль узла под названием Mongoose валюты.

43
00:03:13,250 --> 00:03:16,630
Модуль узла валюты Mongoose

44
00:03:16,630 --> 00:03:21,800
и видел в другом типе схемы для нашего приложения Mongoose,

45
00:03:21,800 --> 00:03:23,770
поэтому сам Mongoose,

46
00:03:23,770 --> 00:03:26,390
безусловно, уже встроенные типы схемы.

47
00:03:26,390 --> 00:03:29,505
Мы видели использование числа,

48
00:03:29,505 --> 00:03:35,550
строки и логического, и массива.

49
00:03:35,550 --> 00:03:39,760
Теперь валюта Mongoose добавляет в поддержку валюты.

50
00:03:39,760 --> 00:03:42,385
Зачем нам нужна эта валютная поддержка?

51
00:03:42,385 --> 00:03:49,040
Таким образом, Mongoose валютный модуль добавляет новый тип, называемый как тип валюты,

52
00:03:49,040 --> 00:03:53,140
который позволяет нам хранить значение валюты.

53
00:03:53,140 --> 00:03:56,650
Поскольку наше блюдо будет содержать цену,

54
00:03:56,650 --> 00:04:00,760
поэтому я собираюсь использовать валютный модуль Mongoose здесь.

55
00:04:00,760 --> 00:04:04,590
Теперь, упражнение здесь,

56
00:04:04,590 --> 00:04:07,545
мы проиллюстрируем использование модуля валюты Mongoose,

57
00:04:07,545 --> 00:04:11,880
вы можете прочитать более подробную информацию о модуле Mongoose валюты узла также,

58
00:04:11,880 --> 00:04:19,010
в документации о том, что ссылка на который предоставляется в дополнительных ресурсах.

59
00:04:19,010 --> 00:04:22,489
Итак, теперь, когда мы установили эти модули узлов,

60
00:04:22,489 --> 00:04:24,890
Mongoose и Mongoose валюты,

61
00:04:24,890 --> 00:04:33,920
давайте перейдем к нашему приложению и настроим его для связи с сервером MongoDB.

62
00:04:33,920 --> 00:04:37,570
Теперь убедитесь, что ваш сервер MongoDB работает и работает.

63
00:04:37,570 --> 00:04:40,070
Итак, здесь вы видите, что

64
00:04:40,070 --> 00:04:44,730
мой сервер MongoDB работает на другой вкладке терминала на моем компьютере.

65
00:04:44,730 --> 00:04:46,670
Если вы используете его на компьютере с Windows,

66
00:04:46,670 --> 00:04:54,005
убедитесь, что он работает в другом командном окне вашего компьютера с Windows.

67
00:04:54,005 --> 00:04:58,525
Перейдя к нашему приложению в редакторе,

68
00:04:58,525 --> 00:05:01,685
мы сначала начнем с файла app.js.

69
00:05:01,685 --> 00:05:03,460
Теперь в файле app.js,

70
00:05:03,460 --> 00:05:07,590
здесь мы создали наше экспресс-приложение ранее.

71
00:05:07,590 --> 00:05:12,935
Но теперь это дополнительное отрицание сосать не подключено к серверному серверу MongoDB.

72
00:05:12,935 --> 00:05:18,085
Мы будем использовать модуль Mongoose,

73
00:05:18,085 --> 00:05:20,430
чтобы установить соединение с сервером.

74
00:05:20,430 --> 00:05:22,385
Итак, зайдя сюда,

75
00:05:22,385 --> 00:05:29,540
я собираюсь добавить модуль Mongoose здесь.

76
00:05:29,540 --> 00:05:35,850
Итак, мы скажем: «Конст Мангуст требует Мангуста».

77
00:05:38,120 --> 00:05:43,280
А затем, так как мы скопировали папку моделей,

78
00:05:43,280 --> 00:05:46,520
в которой содержится файл блюд,

79
00:05:46,520 --> 00:05:51,220
в котором объявляется схема блюд и модель.

80
00:05:51,220 --> 00:05:56,645
Так что, позвольте мне импортировать посуду.

81
00:05:56,645 --> 00:06:04,930
Итак, мы скажем: «Требуется. Слэш модели посуды».

82
00:06:04,930 --> 00:06:07,640
Итак, как только мы завершили это, теперь, конечно,

83
00:06:07,640 --> 00:06:11,000
нам нужно установить соединение с сервером.

84
00:06:11,000 --> 00:06:13,560
Итак, настройте

85
00:06:14,120 --> 00:06:24,960
URL mongodb// localhost7017/путаница,

86
00:06:27,340 --> 00:06:31,150
как мы сделали с упражнением Mongoose,

87
00:06:31,150 --> 00:06:33,140
а затем мы скажем:

88
00:06:33,140 --> 00:06:44,040
«Const connect, URL-адрес подключения Монго».

89
00:06:44,040 --> 00:06:51,450
Таким образом, это точно тот же код, который мы использовали в предыдущем упражнении.

90
00:06:51,450 --> 00:06:53,640
Тогда давайте установим связь.

91
00:06:53,640 --> 00:07:01,695
Итак, мы скажем, «connect», а затем скажем,

92
00:07:01,695 --> 00:07:11,610
«DB сделать это консольный журнал».

93
00:07:11,610 --> 00:07:19,030
Говоря: «Правильно подключено к серверу».

94
00:07:21,020 --> 00:07:26,260
И мы также будем обрабатывать ошибку здесь.

95
00:07:33,980 --> 00:07:40,855
Мы просто сделаем консольный журнал ошибки здесь, вот и все.

96
00:07:40,855 --> 00:07:49,110
Это установит соединение с сервером из нашего файла app.js.

97
00:07:49,110 --> 00:07:52,375
Итак, как только мы установили соединение с сервером

98
00:07:52,375 --> 00:07:58,615
, то давайте откроем файл dishes.js из наших моделей.

99
00:07:58,615 --> 00:08:00,995
Теперь, в файле dishes.js,

100
00:08:00,995 --> 00:08:02,970
чтобы использовать

101
00:08:02,970 --> 00:08:11,760
модуль узла, который мы только что установили.

102
00:08:11,760 --> 00:08:18,990
Итак, мы скажем: «Требовать валюту мангуста» и скажем:

103
00:08:18,990 --> 00:08:26,500
«Загрузите тип и мангуста».

104
00:08:26,500 --> 00:08:32,670
Итак, что это сделает, это загрузить этот новый тип валюты в Mongoose.

105
00:08:32,670 --> 00:08:39,970
После этого, мы можем сказать const,

106
00:08:39,970 --> 00:08:48,705
валюта Mongoose типов валюты.

107
00:08:48,705 --> 00:08:51,720
Вот оно. Итак, этот новый тип,

108
00:08:51,720 --> 00:08:57,880
тип валюты добавляется в Mongoose и это добавит в новый тип, называемый

109
00:08:57,880 --> 00:09:00,160
валютой, а затем я собираюсь объявить

110
00:09:00,160 --> 00:09:04,840
эту постоянную валюту как валюту типов Mongoose.

111
00:09:04,840 --> 00:09:11,630
Чтобы я мог использовать это при определении схемы в моем приложении.

112
00:09:11,630 --> 00:09:14,270
Теперь, в этом случае,

113
00:09:14,270 --> 00:09:17,970
общая схема останется точно такой же, как и раньше, но

114
00:09:17,970 --> 00:09:24,060
схема блюда, как вы помните из файла db.json.

115
00:09:24,060 --> 00:09:28,050
Когда вы посмотрите на структуру документа блюдо,

116
00:09:28,050 --> 00:09:35,630
вы видите, что документ блюдо содержит имя и изображение, которое, как вы видите здесь, является строка,

117
00:09:35,630 --> 00:09:38,570
категория,

118
00:09:38,570 --> 00:09:42,555
метка, цена, которая является строковым типом здесь.

119
00:09:42,555 --> 00:09:46,865
Но мы объявим это как тип валюты,

120
00:09:46,865 --> 00:09:51,495
функция, которая, как вы ожидаете, является Boolean переменной,

121
00:09:51,495 --> 00:09:55,015
и описание, которое является строкой, а затем комментарии,

122
00:09:55,015 --> 00:09:59,755
которые не что иное, как массив типа комментариев.

123
00:09:59,755 --> 00:10:05,790
Теперь, так что мы теперь сделаем, это расширить схему блюда для

124
00:10:05,790 --> 00:10:12,865
поддержки всех этих различных свойств или различных полей в моем документе json.

125
00:10:12,865 --> 00:10:15,225
Итак, у нас уже есть имя.

126
00:10:15,225 --> 00:10:18,505
Итак, у нас уже есть описание на месте.

127
00:10:18,505 --> 00:10:23,730
Поэтому нам нужно добавить в следующие несколько там у нас уже есть комментарии,

128
00:10:23,730 --> 00:10:27,185
массив комментариев типа схемы комментария там.

129
00:10:27,185 --> 00:10:30,075
Так что мы добавим в ближайшие несколько.

130
00:10:30,075 --> 00:10:34,150
Таким образом, следующий, который мы добавим, - это тип изображения,

131
00:10:34,150 --> 00:10:37,640
который будет иметь

132
00:10:37,640 --> 00:10:44,300
строку типа, и

133
00:10:44,300 --> 00:10:49,140
мы скажем, что требуется true.

134
00:10:49,200 --> 00:10:52,240
Таким образом, это добавляет тип изображения.

135
00:10:52,240 --> 00:11:00,460
Следующий, который я добавлю, - это категория,

136
00:11:00,460 --> 00:11:03,865
которая также является типом строки.

137
00:11:03,865 --> 00:11:07,990
Следующим является метка,

138
00:11:07,990 --> 00:11:10,720
которая также является этот тип строки.

139
00:11:10,720 --> 00:11:14,560
Поскольку все это одного типа и требуется,

140
00:11:14,560 --> 00:11:16,625
я просто копирую их здесь.

141
00:11:16,625 --> 00:11:18,464
Затем для метки

142
00:11:18,464 --> 00:11:21,275
я бы сказал, что это не требуется, но

143
00:11:21,275 --> 00:11:26,945
вместо этого я также могу указать значение по умолчанию, если я хочу.

144
00:11:26,945 --> 00:11:29,465
Поэтому я могу указать значение по умолчанию.

145
00:11:29,465 --> 00:11:31,965
Значение по умолчанию - пустая строка.

146
00:11:31,965 --> 00:11:37,245
Поэтому, если я не указываю требуемое, я могу просто указать значение по умолчанию здесь.

147
00:11:37,245 --> 00:11:46,300
Теперь, кроме того, следующее поле, которое я собираюсь ввести, - это ценовое поле.

148
00:11:47,070 --> 00:11:53,575
Поле цены я объявлю тип как валюту.

149
00:11:53,575 --> 00:11:57,085
Напомним, что мы объявляли тип валюты ранее

150
00:11:57,085 --> 00:12:00,380
здесь, сначала требуя

151
00:12:00,380 --> 00:12:03,960
модуль валюты Mongoose, а затем объявляя тип валюты.

152
00:12:03,960 --> 00:12:09,435
Таким образом, вы бы использовали тип валюты в нашем приложении.

153
00:12:09,435 --> 00:12:16,170
Таким образом, мы скажем, валюта типа цены и

154
00:12:16,170 --> 00:12:24,610
требуемая правда, а затем я также могу указать минимальное значение, которое будет нулем.

155
00:12:24,610 --> 00:12:29,590
Затем следующее поле является

156
00:12:29,590 --> 00:12:35,830
избранное поле, которое будет иметь тип Boolean,

157
00:12:35,830 --> 00:12:40,900
и значение по умолчанию будет false.

158
00:12:40,900 --> 00:12:43,625
Итак, если мой документ не хватает этого,

159
00:12:43,625 --> 00:12:47,940
тогда значение по умолчанию будет добавлено в документ здесь.

160
00:12:47,940 --> 00:12:50,470
Поэтому обратите внимание, что теперь я расширил

161
00:12:50,470 --> 00:12:56,825
схему блюда, добавив в тип изображения, категорию,

162
00:12:56,825 --> 00:13:01,710
метку, цену и функцию, чтобы соответствовать

163
00:13:01,710 --> 00:13:07,925
структуре документа блюдо, который я только что показал вам ранее.

164
00:13:07,925 --> 00:13:13,795
Итак, моя схема посуды готова к использованию.

165
00:13:13,795 --> 00:13:20,185
Итак, давайте начнем работать над моим маршрутизатором.

166
00:13:20,185 --> 00:13:21,915
Так где же маршрутизатор?

167
00:13:21,915 --> 00:13:29,530
Вы помните, что маршрутизатор, поддерживающий конечные точки REST API для косой черты,

168
00:13:29,530 --> 00:13:32,110
конечная точка API REST и косой черты,

169
00:13:32,110 --> 00:13:35,170
конечная точка идентификатора косой черты, находится в маршрутизаторе посуды.

170
00:13:35,170 --> 00:13:41,295
Итак, мы перейдем к блюду router.jsfile, а затем мы расширим файл блюдо router.js.

171
00:13:41,295 --> 00:13:46,735
Итак, в блюдо маршрутизатор вместе с Express и BodyParser,

172
00:13:46,735 --> 00:13:55,310
я собираюсь теперь включить Mongoose.

173
00:13:56,640 --> 00:14:03,370
Так что скажем, требуется Mongoose, а

174
00:14:03,370 --> 00:14:10,944
затем нам потребуется модель блюд.

175
00:14:10,944 --> 00:14:12,400
Где модель посуды?

176
00:14:12,400 --> 00:14:20,080
Он внутри. /модель/посуда.

177
00:14:20,080 --> 00:14:22,405
Значит, он там.

178
00:14:22,405 --> 00:14:24,470
Поэтому обратите внимание, что мы находимся в папке маршрутизатора,

179
00:14:24,470 --> 00:14:27,610
поэтому вам нужно подняться на один уровень, а затем перейти

180
00:14:27,610 --> 00:14:31,460
в папку модели, а затем файл dishes.js находится прямо там.

181
00:14:31,460 --> 00:14:34,010
Вот что мы импортируем здесь.

182
00:14:34,010 --> 00:14:41,039
Итак, теперь я могу обновить мой маршрутизатор посуды, чтобы иметь возможность взаимодействовать

183
00:14:41,039 --> 00:14:46,330
с сервером Mongoose с помощью

184
00:14:46,330 --> 00:14:52,175
Mongoose, и мы уже импортировали модель блюд в мой маршрутизатор посуды.

185
00:14:52,175 --> 00:14:57,720
Итак, пришло время мне пойти и обновить все методы здесь.

186
00:14:57,720 --> 00:14:59,465
Так что для блюдо маршрутизатор, косая

187
00:14:59,465 --> 00:15:03,665
черта, что означает, что конечная точка слэша блюда.

188
00:15:03,665 --> 00:15:07,880
Я собираюсь удалить все это отсюда, вместо этого

189
00:15:07,880 --> 00:15:12,040
я собираюсь явно объявить все различные конечные точки.

190
00:15:12,040 --> 00:15:16,995
Чтобы получить сообщение и удалить, я буду обрабатывать каждый из них самостоятельно.

191
00:15:16,995 --> 00:15:19,135
Итак, в методе get

192
00:15:19,135 --> 00:15:24,360
я собираюсь вырезать это, а затем в методе get, что мне нужно сделать?

193
00:15:24,360 --> 00:15:32,760
Напомним, что мы определили метод от Mongoose, который позволяет нам найти все блюда.

194
00:15:32,760 --> 00:15:36,365
Поэтому, когда вы выполняете операцию get на конечной точке косой черты,

195
00:15:36,365 --> 00:15:39,600
вы ожидаете, что все блюда будут возвращены

196
00:15:39,600 --> 00:15:44,005
клиенту в ответ на запрос get.

197
00:15:44,005 --> 00:15:49,890
Итак, я собираюсь пойти в посуду, а затем выполнить операцию поиска.

198
00:15:49,890 --> 00:15:53,040
Итак, теперь вы видите, что с моего сервера Express

199
00:15:53,040 --> 00:15:58,585
я получаю доступ к моему MongoDB.

200
00:15:58,585 --> 00:16:06,520
Итак, будет делать находку и в находке я собираюсь теперь обрабатывать запрос.

201
00:16:06,520 --> 00:16:08,310
Так что я могу сказать,

202
00:16:08,310 --> 00:16:13,885
что посуда найдет, так как это вернет обещание,

203
00:16:13,885 --> 00:16:16,765
тогда я смогу справиться с этим здесь.

204
00:16:16,765 --> 00:16:24,520
Итак, я скажу блюдо, и поэтому, если обещание разрешится правильно,

205
00:16:24,520 --> 00:16:33,529
я получу его в то время, и поэтому я скажу блюдо, а затем мы будем обрабатывать

206
00:16:33,960 --> 00:16:41,125
код статуса res 200, а затем мы скажем,

207
00:16:41,125 --> 00:16:48,920
тип содержимого заголовка res set.

208
00:16:53,100 --> 00:16:57,830
Поскольку мы собираемся вернуть значение как json,

209
00:16:57,830 --> 00:17:00,770
поэтому мы установим это для приложения json.

210
00:17:00,770 --> 00:17:03,580
Хорошо, это вернет массив блюд.

211
00:17:03,580 --> 00:17:07,955
Поэтому я могу просто сказать блюда, а затем мы скажем res.json.

212
00:17:07,955 --> 00:17:12,650
Таким образом, res.json возьмет в качестве ввода в строку json,

213
00:17:12,650 --> 00:17:17,680
а затем отправит его обратно моему клиенту.

214
00:17:17,680 --> 00:17:21,785
Итак, когда вы вызываете res.json и предоставляете значение, а затем он просто

215
00:17:21,785 --> 00:17:27,650
возьмет параметр, который вы даете здесь, а затем отправит его обратно в качестве ответа json.

216
00:17:27,650 --> 00:17:30,365
Он поместит эти блюда в тело

217
00:17:30,365 --> 00:17:33,835
ответного сообщения, а затем отправит его обратно на сервер.

218
00:17:33,835 --> 00:17:39,560
Теперь мы можем обработать ошибку

219
00:17:39,560 --> 00:17:47,370
здесь, сказав следующую ошибку.

220
00:17:48,100 --> 00:17:59,140
Мы также можем сделать ошибку catch только ради завершения.

221
00:17:59,140 --> 00:18:03,290
Я просто собираюсь поставить оба этих на место здесь,

222
00:18:03,290 --> 00:18:05,960
так что оба будут обрабатываться как таковые.

223
00:18:05,960 --> 00:18:08,305
Поэтому, если ошибка

224
00:18:08,305 --> 00:18:11,740
возвращается, это просто передаст ошибку в

225
00:18:11,740 --> 00:18:15,260
общий обработчик ошибок для моего приложения,

226
00:18:15,260 --> 00:18:18,985
и пусть беспокоится о том, как справиться с ошибкой.

227
00:18:18,985 --> 00:18:21,490
Так что мы отправим его на это.

228
00:18:21,490 --> 00:18:28,610
Таким образом, вы видите, как я использую операцию поиска, а затем выполняю запрос здесь.

229
00:18:28,610 --> 00:18:30,595
Теперь, для поста,

230
00:18:30,595 --> 00:18:32,904
как вы уже ожидали,

231
00:18:32,904 --> 00:18:37,100
я собираюсь сделать dishes.create,

232
00:18:38,790 --> 00:18:43,425
потому что мы собираемся создать новое блюдо здесь.

233
00:18:43,425 --> 00:18:47,195
Итак, напомним, что мы уже видели, что блюда создают

234
00:18:47,195 --> 00:18:52,400
использование метода раньше и помните, что анализатор тела

235
00:18:52,400 --> 00:18:56,950
уже проанализировал бы все, что находится в теле сообщения, и загрузил его

236
00:18:56,950 --> 00:19:01,510
в свойство body запроса.

237
00:19:01,510 --> 00:19:08,650
Итак, я просто собираюсь взять тело запроса, а затем проанализировать его в качестве параметра для моего

238
00:19:08,650 --> 00:19:16,120
метода dises.create и обработать возвращаемое значение.

239
00:19:16,120 --> 00:19:21,325
Итак, мы скажем тогда, и это вернут

240
00:19:21,325 --> 00:19:26,755
блюдо, и мы разберемся с этим здесь.

241
00:19:26,755 --> 00:19:35,220
Так что мы скажем, если блюда возвращаются правильно и если блюда выложены правильно, скажет res.

242
00:19:36,060 --> 00:19:43,045
Хорошо, давайте сделаем console.log для нашего собственного использования.

243
00:19:43,045 --> 00:19:52,330
На стороне сервера мы сделаем console.log, говорящее «блюдо создано» здесь.

244
00:19:52,330 --> 00:20:02,125
Давайте запишем это блюдо на консоль, а затем мы скажем эти два кода состояния отдыха.

245
00:20:02,125 --> 00:20:09,820
Мы просто скопируем этот код, а затем вставьте его туда, и в этом случае

246
00:20:09,820 --> 00:20:12,445
мы возвращаем блюдо здесь.

247
00:20:12,445 --> 00:20:16,480
Блюдо, которое пришло в качестве параметра здесь, а затем позволяет

248
00:20:16,480 --> 00:20:22,825
клиенту иметь дело с этим значением на стороне клиента, что

249
00:20:22,825 --> 00:20:24,985
бы ни было возвращено в блюдо.

250
00:20:24,985 --> 00:20:27,745
Теперь, также они добавят в

251
00:20:27,745 --> 00:20:41,770
это здесь, а потом улов.

252
00:20:41,770 --> 00:20:44,860
Так вот как мы обрабатываем сообщение.

253
00:20:44,860 --> 00:20:47,830
Для PUT, потому что PUT не допускается,

254
00:20:47,830 --> 00:20:50,365
поэтому мы собираемся оставить его как таковой.

255
00:20:50,365 --> 00:20:54,250
Для DELETE мы будем удалять все блюда.

256
00:20:54,250 --> 00:21:02,240
Так что мы скажем: «Посуда. Уберите».

257
00:21:03,990 --> 00:21:08,185
Это, по сути, опасная операция.

258
00:21:08,185 --> 00:21:11,080
Таким образом, вы удаляете все блюда с

259
00:21:11,080 --> 00:21:18,610
сервера, и поэтому мы скажем:

260
00:21:18,610 --> 00:21:25,600
«Dishes.Remove then», и «then» получит некоторый ответ.

261
00:21:25,600 --> 00:21:32,200
Поэтому мы просто скажем: «resp here», и способ, которым мы будем обрабатывать

262
00:21:32,200 --> 00:21:40,550
этот ответ, - просто взять это значение, а затем вернуть его клиенту.

263
00:21:40,620 --> 00:21:48,550
Таким образом, мы скажем: «res.StatusCode 200 типа содержимого application json», а

264
00:21:48,550 --> 00:21:56,660
затем мы просто отправим ответ клиенту, и мы будем обрабатывать ошибку,

265
00:22:06,000 --> 00:22:08,830
как мы делали ранее.

266
00:22:08,830 --> 00:22:10,390
Это операция DELETE.

267
00:22:10,390 --> 00:22:14,110
Таким образом, вы видите, что теперь мы выполняем

268
00:22:14,110 --> 00:22:17,545
операции GET, POST, PUT и DELETE.

269
00:22:17,545 --> 00:22:26,425
Теперь мы будем продолжать то же самое с конечной точкой /DishID.

270
00:22:26,425 --> 00:22:28,270
Так что в этом случае,

271
00:22:28,270 --> 00:22:34,040
мы специально мотив получения конкретного блюда.

272
00:22:34,040 --> 00:22:39,480
Мы собираемся вернуть эту специфическую ценность блюда.

273
00:22:39,480 --> 00:22:41,445
Таким образом, в GET,

274
00:22:41,445 --> 00:22:51,275
то, что мы делаем, мы скажем «Dishes.FindByID.

275
00:22:51,275 --> 00:22:57,965
Таким образом, findByID - это метод, который доступен из mongo, а также из драйвера MongoDB.

276
00:22:57,965 --> 00:23:02,020
Так что мы скажем: «Req.params.dishid».

277
00:23:03,600 --> 00:23:11,030
Напомним, что мы уже знаем, что блюдо ID присутствует в свойстве params.

278
00:23:11,030 --> 00:23:14,140
Вы уже узнали об этом раньше.

279
00:23:14,140 --> 00:23:20,260
Так что я скажу: «Найди ID (req.params.dishid)»,

280
00:23:20,260 --> 00:23:24,565
а затем и другое.

281
00:23:24,565 --> 00:23:30,520
Поэтому я просто собираюсь скопировать это тогда и еще

282
00:23:30,520 --> 00:23:38,170
оттуда, а затем спуститься на DishRouter, а

283
00:23:38,170 --> 00:23:46,150
затем просто вставить это здесь.

284
00:23:46,150 --> 00:23:49,190
Итак, мы скажем: "Res.StatusCode200

285
00:23:49,440 --> 00:23:55,585
приложение json.res.jsondish, а затем обработка ошибок.

286
00:23:55,585 --> 00:24:05,350
Для POST, очевидно, мы не будем обрабатывать сообщение для конечной точки /dishID.

287
00:24:05,350 --> 00:24:07,635
Так что мы оставим его как таковое.

288
00:24:07,635 --> 00:24:12,740
Для PUT мы будем обновлять

289
00:24:12,740 --> 00:24:17,975
конкретное блюдо, которое идентифицируется его идентификатор блюда.

290
00:24:17,975 --> 00:24:25,270
Так вот, где мы будем использовать тарелы.Findbyidandupdate.

291
00:24:25,270 --> 00:24:27,690
Таким образом, это метод, который мы будем использовать,

292
00:24:27,690 --> 00:24:35,539
findByIDandUpdate, и это принимает в качестве первого параметра

293
00:24:37,410 --> 00:24:44,410
req.params.dishid, а второе значение -

294
00:24:44,410 --> 00:24:53,290
набор, и обновление

295
00:24:53,290 --> 00:24:55,150
будет в теле сообщения.

296
00:24:55,150 --> 00:24:57,580
Так что я просто собираюсь получить это из

297
00:24:57,580 --> 00:25:05,410
тела req, а затем еще и другой флаг, который я собираюсь иметь.

298
00:25:05,410 --> 00:25:10,840
Так скажем, «new: true», так что этот метод findByID вернет

299
00:25:10,840 --> 00:25:18,730
обновленное блюдо как строку json в ответе.

300
00:25:18,730 --> 00:25:23,650
Это то, что я собираюсь получить здесь, а затем, когда это значение придет,

301
00:25:23,650 --> 00:25:26,230
я просто возьму блюдо, а

302
00:25:26,230 --> 00:25:39,040
затем просто верну блюдо на стороне клиента.

303
00:25:39,040 --> 00:25:47,095
Поэтому я скажу res.jason (блюдо), а затем мы будем обрабатывать ошибку соответственно.

304
00:25:47,095 --> 00:25:49,090
Наконец для DELETE.

305
00:25:49,090 --> 00:25:50,695
Для DELETE снова,

306
00:25:50,695 --> 00:25:54,880
соответствующий метод, который мы собираемся

307
00:25:54,880 --> 00:26:01,165
использовать является метод Монго под названием FindByIandRemove.

308
00:26:01,165 --> 00:26:03,760
Таким образом, вы можете видеть, что у нас есть этот метод под названием

309
00:26:03,760 --> 00:26:08,080
findByIandRemove, и это

310
00:26:08,080 --> 00:26:18,355
findByIdAndRemove, будет принимать req.params.dishid, потому что это блюдо, которое мы пытаемся удалить.

311
00:26:18,355 --> 00:26:20,970
Затем, когда это удаляется,

312
00:26:20,970 --> 00:26:23,940
так же, как мы обрабатывали это здесь,

313
00:26:23,940 --> 00:26:30,830
поэтому я просто собираюсь скопировать этот код из Dishes.Remove.

314
00:26:30,830 --> 00:26:34,350
То же самое, что я собираюсь делать здесь тоже.

315
00:26:34,350 --> 00:26:38,750
Поэтому findByIDandRemove и любой ответ, который

316
00:26:38,750 --> 00:26:41,970
я получаю, я собираюсь вернуть его своему клиенту.

317
00:26:41,970 --> 00:26:45,490
С этим мы обновили DishRouter.

318
00:26:45,490 --> 00:26:49,960
Давайте сохраним все изменения, которые мы сделали

319
00:26:49,960 --> 00:26:57,185
до сих пор, а затем мы пойдем и запустим наш сервер, а затем посмотрим, что он делает.

320
00:26:57,185 --> 00:27:01,370
Таким образом, перейдя в терминал или окно команд, запустите сервер.

321
00:27:01,370 --> 00:27:06,045
Поэтому я скажу «npm start», и сервер теперь работает и работает.

322
00:27:06,045 --> 00:27:12,030
Мы будем использовать почтальона для связи с этим сервером.

323
00:27:12,030 --> 00:27:15,700
Так что давайте пойдем к почтальона, а затем выполним определенные операции.

324
00:27:15,700 --> 00:27:19,030
Вот видишь, как мой почтальон бежит сюда.

325
00:27:19,030 --> 00:27:26,450
Поэтому позвольте мне выполнить операцию GET на локальном хосте: 3000/блюда.

326
00:27:28,300 --> 00:27:31,875
Поэтому, когда вы выполняете операцию GET, как вы видите,

327
00:27:31,875 --> 00:27:33,205
она вернет пустую строку.

328
00:27:33,205 --> 00:27:36,715
Моя база данных теперь пуста, поэтому у меня ничего нет.

329
00:27:36,715 --> 00:27:40,205
Поэтому я просто собираюсь вернуть пустую строку.

330
00:27:40,205 --> 00:27:45,600
Давай поставим блюдо.

331
00:27:46,020 --> 00:27:48,340
Поэтому, когда вы размещаете блюдо,

332
00:27:48,340 --> 00:27:50,254
очевидно, в теле,

333
00:27:50,254 --> 00:27:58,175
вы будете заключать блюдо, и тело будет установлено как тип json приложения.

334
00:27:58,175 --> 00:28:00,785
Теперь, чтобы опубликовать блюдо,

335
00:28:00,785 --> 00:28:06,770
я уже дал вам файл db.json в ресурсах упражнений.

336
00:28:06,770 --> 00:28:10,880
Поэтому просто откройте файл db.json, а затем скопируйте самое первое блюдо оттуда,

337
00:28:10,880 --> 00:28:15,390
а затем мы вставьте его здесь, а затем разместите это блюдо.

338
00:28:15,390 --> 00:28:18,735
Итак, позвольте мне перейти к файлу db.jason.

339
00:28:18,735 --> 00:28:21,550
Позвольте мне скопировать самое первое блюдо отсюда.

340
00:28:21,550 --> 00:28:22,810
Так что я просто скопирую

341
00:28:22,810 --> 00:28:32,765
все блюдо вплоть до туда, а потом отправлю это блюдо.

342
00:28:32,765 --> 00:28:36,610
Это содержит много полей, которые у нас уже есть.

343
00:28:36,610 --> 00:28:39,895
Давайте разместим это блюдо на сервере и посмотрим, что произойдет.

344
00:28:39,895 --> 00:28:44,605
Так что возвращаюсь к почтальну.

345
00:28:44,605 --> 00:28:47,620
Здесь, в форме данных,

346
00:28:47,620 --> 00:28:51,535
в теле, позвольте мне вставить блюдо на место.

347
00:28:51,535 --> 00:28:54,760
Итак, у нас есть полная информация о блюде.

348
00:28:54,760 --> 00:28:58,010
Давайте POST это блюдо на сервер.

349
00:28:58,320 --> 00:29:01,780
Затем, как только блюдо отправлено на сервер,

350
00:29:01,780 --> 00:29:06,580
вы видите, что Почтальон имеет,

351
00:29:06,580 --> 00:29:09,700
позвольте мне просто уменьшить это,

352
00:29:09,700 --> 00:29:18,370
а затем вы видите внизу, что это конкретное блюдо было отправлено в базу данных, в базу данных

353
00:29:18,370 --> 00:29:20,290
MongoDB моим сервером.

354
00:29:20,290 --> 00:29:23,560
Итак, вы видите, что возвращаемое значение

355
00:29:23,560 --> 00:29:30,760
здесь показывает, когда блюдо было вставлено на этот сервер.

356
00:29:30,760 --> 00:29:35,020
Таким образом, у вас есть CreateDat и UpdateDat.

357
00:29:35,020 --> 00:29:39,880
Вы видите, что все остальные поля хранятся там.

358
00:29:39,880 --> 00:29:45,865
Обратите внимание, в частности, на то, как хранится цена.

359
00:29:45,865 --> 00:29:49,820
Так валюта хранит стоимость цены.

360
00:29:50,630 --> 00:29:53,825
Таким образом, когда вы получаете возвращаемое значение,

361
00:29:53,825 --> 00:29:59,370
вам нужно правильно интерпретировать это на стороне клиента, что это означает.

362
00:29:59,370 --> 00:30:08,510
Обратите внимание также, что идентификатор был добавлен в мое блюдо и для каждого самого комментария,

363
00:30:08,510 --> 00:30:11,445
потому что каждый из комментариев сам по себе является вложенным документом.

364
00:30:11,445 --> 00:30:14,370
У вас будут добавлены UpdateDat и CreateDat,

365
00:30:14,370 --> 00:30:21,115
а идентификатор для каждого из комментариев также добавляется туда автоматически моей базой данных.

366
00:30:21,115 --> 00:30:23,080
Вот ты идешь. Итак,

367
00:30:23,080 --> 00:30:26,875
это блюдо добавлено в мою базу данных.

368
00:30:26,875 --> 00:30:29,589
Давайте снова выполним операцию GET,

369
00:30:29,589 --> 00:30:32,244
и, очевидно,

370
00:30:32,244 --> 00:30:37,135
на этом этапе сервер должен вернуть это конкретное блюдо, которое было добавлено в.

371
00:30:37,135 --> 00:30:39,775
Таким образом, он вернет массив блюд здесь,

372
00:30:39,775 --> 00:30:42,190
так что, как вы можете видеть, он возвращает массив блюд.

373
00:30:42,190 --> 00:30:44,050
Конечно, этот массив содержит только одно блюдо

374
00:30:44,050 --> 00:30:47,245
, или это конкретное блюдо было возвращено сюда.

375
00:30:47,245 --> 00:30:49,585
Пока что, так хорошо.

376
00:30:49,585 --> 00:30:54,895
Итак, давайте сделаем PUT на посуду и посмотрим, что произойдет.

377
00:30:54,895 --> 00:30:56,980
Когда вы делаете PUT, очевидно, он говорит:

378
00:30:56,980 --> 00:31:02,255
«Операция PUT не поддерживается на блюдах», как мы ожидаем.

379
00:31:02,255 --> 00:31:03,770
Давайте сделаем DELETE.

380
00:31:03,770 --> 00:31:05,575
Выполняя операцию DELETE,

381
00:31:05,575 --> 00:31:09,030
он возвращает этот ответ, говорящий:

382
00:31:09,030 --> 00:31:10,890
«N равно одному», хорошо,

383
00:31:10,890 --> 00:31:13,570
один означает, что он удалил одно блюдо.

384
00:31:13,570 --> 00:31:15,660
Давайте теперь снова, выполним операцию GET,

385
00:31:15,660 --> 00:31:22,850
и тогда вы увидите, что мои блюда пусты, как мы ожидали.

386
00:31:22,980 --> 00:31:25,930
Таким образом, вы видите, что

387
00:31:25,930 --> 00:31:28,405
операции GET, PUT, POST и DELETE работают правильно.

388
00:31:28,405 --> 00:31:31,225
Теперь позвольте мне POST блюдо снова

389
00:31:31,225 --> 00:31:36,110
на сервер, потому что я хочу иметь одно блюдо на сервере.

390
00:31:36,270 --> 00:31:38,725
Итак, позвольте мне POST это блюдо,

391
00:31:38,725 --> 00:31:41,425
и вы заметите, что идентификатор теперь изменился.

392
00:31:41,425 --> 00:31:44,110
Итак, позвольте мне выбрать этот идентификатор,

393
00:31:44,110 --> 00:31:50,630
а затем мы сделаем GET с идентификатором на месте.

394
00:31:51,990 --> 00:31:55,405
Когда вы делаете GET с идентификатором на месте,

395
00:31:55,405 --> 00:32:02,300
вы видите, что он возвращает это конкретное блюдо, как вы его ожидаете.

396
00:32:02,760 --> 00:32:07,630
Давайте перейдем к терминалу и посмотрим, что

397
00:32:07,630 --> 00:32:12,125
печатается на терминале или в вашем командном окне.

398
00:32:12,125 --> 00:32:15,300
Итак, перейдя к терминалу или вашему командному окну,

399
00:32:15,300 --> 00:32:19,360
вы видите, что он распечатывает все эти вещи в командном окне.

400
00:32:19,360 --> 00:32:21,540
Итак, когда мы сделали первую операцию GET,

401
00:32:21,540 --> 00:32:22,640
он говорит: GET /dishes.

402
00:32:22,640 --> 00:32:24,375
Итак, это снова,

403
00:32:24,375 --> 00:32:28,155
Морган делает эту работу для вас, он распечатывает,

404
00:32:28,155 --> 00:32:31,170
отслеживает эту информацию и говорит,

405
00:32:31,170 --> 00:32:34,575
что блюдо создано, а затем эта конкретная информация о блюде была напечатана,

406
00:32:34,575 --> 00:32:38,190
а затем он говорит POST /блюда, GET /блюда,

407
00:32:38,190 --> 00:32:41,130
а затем, когда вы сделали PUT, он вернул 403

408
00:32:41,130 --> 00:32:44,170
там и вы снова создали блюда и так далее.

409
00:32:44,170 --> 00:32:47,145
Итак, вы видите, что ваш сервер фактически выполняет всю работу,

410
00:32:47,145 --> 00:32:53,110
и эти вещи вставляются в вашу базу данных MongoDB, как вы ожидали.

411
00:32:53,110 --> 00:32:58,540
Теперь, возвращаясь к почтальну,

412
00:32:58,540 --> 00:33:00,850
давайте сделаем POST на посуду.

413
00:33:00,850 --> 00:33:03,605
Теперь это не поддерживается на стороне сервера,

414
00:33:03,605 --> 00:33:04,750
поэтому ваш сервер должен сказать:

415
00:33:04,750 --> 00:33:10,225
«Операция POST не поддерживается на этой конкретной конечной точке», как вы можете этого ожидать.

416
00:33:10,225 --> 00:33:13,070
Давайте сделаем операцию PUT.

417
00:33:14,430 --> 00:33:17,190
Когда вы выполняете операцию PUT,

418
00:33:17,190 --> 00:33:20,955
то, что я собираюсь сделать в операции PUT, заключается

419
00:33:20,955 --> 00:33:26,860
в том, что я собираюсь заменить метку там.

420
00:33:26,860 --> 00:33:29,550
Итак, в моем теле сообщения.

421
00:33:29,550 --> 00:33:34,570
Итак, напомним, что если вы посмотрите на файл db.json,

422
00:33:34,570 --> 00:33:38,180
метка для этого будет новой,

423
00:33:38,180 --> 00:33:51,160
и поэтому я собираюсь изменить эту метку на горячую.

424
00:33:51,160 --> 00:33:53,040
Поскольку это должно быть в Json,

425
00:33:53,040 --> 00:33:57,895
поэтому маркируйте также в кавычках Json ярлык горячий,

426
00:33:57,895 --> 00:34:02,810
а затем давайте сделаем PUT на этой конкретной конечной точке.

427
00:34:04,080 --> 00:34:07,615
Операция PUT была успешной,

428
00:34:07,615 --> 00:34:12,280
и поэтому вы видите, что когда операция PUT была выполнена,

429
00:34:12,280 --> 00:34:19,150
вы заметили, что метка теперь изменилась с нового на горячий здесь,

430
00:34:19,150 --> 00:34:22,630
и обратите внимание, в частности,

431
00:34:22,630 --> 00:34:28,900
значение CreateDat и значение UpdateDat.

432
00:34:28,900 --> 00:34:31,990
Итак, обратите внимание, что эта запись была создана

433
00:34:31,990 --> 00:34:36,970
в этот момент времени и обновлена немного позже.

434
00:34:36,970 --> 00:34:40,000
Итак, обновление было сделано операцией PUT, которую я только что

435
00:34:40,000 --> 00:34:43,450
выполнил на этом конкретном блюде.

436
00:34:43,450 --> 00:34:46,240
Давайте удалим блюдо.

437
00:34:46,240 --> 00:34:49,795
Это разрешено. Итак, мы удалим блюдо,

438
00:34:49,795 --> 00:34:54,100
а затем блюдо будет удалено и значение будет возвращено.

439
00:34:54,100 --> 00:34:58,930
Теперь, если вы выполняете операцию GET

440
00:34:58,930 --> 00:35:04,615
на конечной точке блюд, вы увидите, что это вернет пустой.

441
00:35:04,615 --> 00:35:09,385
Итак, вам просто удалось удалить блюдо из нашей базы данных.

442
00:35:09,385 --> 00:35:14,095
То, что я собираюсь сделать, это выполнить

443
00:35:14,095 --> 00:35:20,630
операцию GET на несуществующем блюде и посмотреть, что происходит.

444
00:35:20,630 --> 00:35:23,905
Когда я выполняю операцию GET на несуществующем блюде,

445
00:35:23,905 --> 00:35:27,300
он возвращает null, потому что это блюдо не существует.

446
00:35:27,300 --> 00:35:31,570
Таким образом, он возвращает нулевое значение, говорящее, что блюдо не существует.

447
00:35:31,570 --> 00:35:40,525
Теперь позвольте мне выполнить операцию GET на не-ObjectID и посмотреть, что происходит.

448
00:35:40,525 --> 00:35:44,980
Он возвращается, как вы видите.

449
00:35:44,980 --> 00:35:46,465
Позволь мне просмотреть это.

450
00:35:46,465 --> 00:35:51,840
Итак, он говорит: «Cast to ObjectID не удалось получить значение здесь на пути».

451
00:35:51,840 --> 00:35:53,840
Итак, я буду очевидно, что это не

452
00:35:53,840 --> 00:35:57,565
действительный ObjectID, поэтому мне просто удалось удалить его часть,

453
00:35:57,565 --> 00:36:02,050
а затем выполнить операцию, чтобы он вернул ошибку, сказав,

454
00:36:02,050 --> 00:36:04,915
поэтому вы видите, что есть 500 внутренних ошибок сервера.

455
00:36:04,915 --> 00:36:09,505
Сервер не смог справиться с этим, а затем вернуть это значение здесь.

456
00:36:09,505 --> 00:36:11,925
Итак, там написано: «Нет,

457
00:36:11,925 --> 00:36:13,230
это запрещено».

458
00:36:13,230 --> 00:36:18,385
Таким образом, потому что это не действительный ObjectID.

459
00:36:18,385 --> 00:36:22,275
Таким образом, даже ошибки обрабатываются соответствующим образом, как вы видите здесь.

460
00:36:22,275 --> 00:36:26,050
Итак, позвольте мне еще раз сделать операцию GET на блюдах,

461
00:36:26,050 --> 00:36:27,975
и ваш сервер все еще работает,

462
00:36:27,975 --> 00:36:30,650
и он вернет пустое значение здесь.

463
00:36:30,650 --> 00:36:34,465
Итак, мы видели, как, изменив

464
00:36:34,465 --> 00:36:40,900
наш REST API сервер, чтобы иметь возможность взаимодействовать с сервером MongoDB.

465
00:36:40,900 --> 00:36:45,775
Теперь у нас есть полноценный сервер REST API, который может хранить,

466
00:36:45,775 --> 00:36:48,090
и извлекать, и выполнять различные операции с

467
00:36:48,090 --> 00:36:51,220
данными, которые хранятся на моем сервере MongoDB.

468
00:36:51,220 --> 00:36:54,535
С этим мы завершаем это упражнение.

469
00:36:54,535 --> 00:36:56,290
Итак, в этом упражнении

470
00:36:56,290 --> 00:37:05,200
мы видели, как мы можем взаимодействовать с нашим сервером REST API,

471
00:37:05,200 --> 00:37:07,560
и, в свою очередь, с сервером MongoDB,

472
00:37:07,560 --> 00:37:12,400
а затем мы используем сервер MongoDB для хранения и извлечения данных с сервера.

473
00:37:12,400 --> 00:37:14,770
Вы можете взаимодействовать из

474
00:37:14,770 --> 00:37:20,225
нашего приложения Express с сервером Mongoose с помощью Mongoose.

475
00:37:20,225 --> 00:37:24,700
Это хорошее время для вас сделать фиксацию GIT с сообщением

476
00:37:24,700 --> 00:37:31,550
«Express REST API с Mongoose Part One».