Теперь, когда мы узнали о Mongoose Population,
и как это позволяет нам заполнить один документ информацией из другого документа.
В этом упражнении мы изменим экспресс-сервер, над которым мы работали до сих пор.
В схеме блюда, которую мы определили ранее, у нас были комментарии.
Для комментариев у нас было поле автора
, которое мы используем для хранения деталей об авторе.
В этом упражнении мы превратим поле автора в ссылку на документ пользователя,
и мы будем использовать Mongoose популяции, чтобы заполнить информацию
в документ блюда по мере необходимости,
чтобы предоставить информацию клиенту.
Теперь использование популяции и мангуста должно быть сделано
разумно, чтобы не вызывать слишком много накладных расходов на стороне сервера.
Теперь в этом упражнении
мы будем использовать его просто, чтобы заполнить информацию
в поле автора наших комментариев.
Итак, давайте продолжим упражнение, чтобы узнать, как мы используем популяцию Мангуста.
Чтобы начать работу с этим упражнением,
перейдите в проект и откройте файл user.js.
Итак, в файле user.js
мы храним пользовательскую схему.
Я собираюсь изменить схему пользователя, добавив еще пару полей там.
Одним из них является имя,
которое будет
строки типа и
по умолчанию будет пустая строка.
Итак, первое имя, как следует из имени,
хранит имя для пользователя, а затем у нас будет другое поле, называемое фамилией,
которое также имеет тот же вид.
Итак, я просто собираюсь скопировать эти две части информации, а затем скопировать ее
здесь и так теперь наш пользовательский документ будет содержать,
в дополнение к имени пользователя и пароля, имя пользователя и
тихо и соль, которые мы видели ранее,
который автоматически добавляется паспортом локального модуля Mongoose .
Мы также будем иметь имя и фамилию для пользователя, определяемого здесь.
Позже мы увидим, как мы будем инициализировать
эти значения путем изменения процесса регистрации пользователя.
Теперь, как только мы завершили
это, так что таким образом информацию пользователя
можно просто получить, просматривая документ пользователя здесь.
Итак, теперь, когда у нас есть информация о пользователе в пользовательском документе,
идя в схему блюдо,
поэтому перейдя в файл dishes.js.
В схеме тарелки ранее
мы хранили автора документа в виде строки здесь.
Теперь мы будем использовать тот факт, что
у нас есть поддержка популяции мангуста.
Поэтому я собираюсь превратить поле комментария из строки в
идентификатор объекта типа схемы мангуста.
Итак, простите, неправильное поле.
Я имел в виду превратить поле автора в
идентификатор объекта типа схемы мангуста.
Таким образом, поле автора теперь вместо хранения строки
будет иметь ссылку на документ пользователя.
Итак, когда я превращаю поле автора в этот тип,
второе свойство, которое я определил здесь, будет ссылкой,
которая будет ссылкой на пользовательскую модель.
Таким образом, мы теперь будем
соединять это поле автора, и это поле автора будет
просто хранить ссылку на идентификатор документа пользователя,
вместо того, чтобы хранить детали об авторе в виде имени.
Теперь, когда мы это делаем,
мы можем использовать mongoose populate, чтобы заполнить
эту информацию в нашем документе блюд всякий раз, когда это необходимо.
Таким образом, с этой модификацией схемы блюд, в файле dishes.js,
мы теперь обновим маршрутизатор блюд, чтобы использовать популяцию мангуста.
Итак, переходим к dishRouter.js.
В блюдо роутер, вспомните, что когда мы получали блюдо здесь,
теперь, когда вы получаете блюдо здесь,
мы говорим, блюда найти тогда.
Так что, прямо в этот момент,
мы скажем, блюда найти и мы скажем после этого, заполнить.
Итак, мы используем поддержку населения в мангусте,
и мы скажем, заполнять комментарии автора.
Таким образом, заявив это,
мы говорим, когда
документ блюд был построен, чтобы отправить ответ пользователю,
мы собираемся заполнить поле автора внутри там из документа пользователя там.
Таким образом, этот вызов заполнению гарантирует, что
другое поле будет заполнено информацией по мере необходимости.
Точно так же, идя на блюдо ID здесь,
даже в блюдо ID, то же самое.
Мы скажем, заполнение и комментарии автора добавлены
в блюда найти по id
в get конечной точки /dish ID.
Аналогичным образом, в комментариях также, когда мы извлекаем блюдо,
мы скажем, заполнить комментарии автора здесь и
то же самое также в маршрутизаторе
блюдо, комментарии идентификатор блюда, идентификатор комментария также.
Чем больше заполняет эту информацию там.
Теперь, конечно, это означает, что когда вы размещаете блюдо,
раньше вы включаете информацию об авторе в текст сообщения.
Итак, теперь здесь, когда мы пытаемся нажать комментарий в это,
так что этот пост соответствует поле комментариев идентификатора блюда.
Итак, вот как мы размещали комментарий к конкретному блюду.
Итак, теперь в этом посте,
так как мы больше не храним информацию об авторе,
так что нам нужно сделать, это когда мы нажимаем элемент в поле автора там.
Итак, здесь, когда вы заполняете информацию в блюдо,
мы должны сначала
напомнить, что тело содержит комментарий уже,
но свойство автора не будет там в теле сообщения в книге,
но в зависимости от того, какой пользователь публикует эту информацию,
мы можем немедленно заполнить поле автора.
Теперь, как мы узнаем, какой пользователь публикует эту информацию?
Тот факт, что мы выполнили проверку пользователя здесь для сообщения,
означает, что конкретный пользователь публикует эту информацию,
и, выполняя проверку пользователя,
мы бы уже загрузились в req.user в объект запроса.
В объекте запроса
мы можем войти и сказать user wreck,
а затем подчеркнуть идентификатор здесь.
Итак, позвольте мне еще раз повторить этот момент:
как мы получаем здесь информацию автора?
Теперь напомним, что мы обновили схему блюд,
так что поле автора в комментарии просто сохранит
идентификатор объекта, ссылающийся на пользователя, который публикует этот комментарий.
Теперь, как мы узнаем, какой пользователь публикует этот комментарий?
Теперь снова, чтобы повторить этот момент,
напомним, что когда мы проверили пользователя здесь, вызвав пользователя аутентификации,
авторизованный паспорт JWT загрузил бы
информацию пользователя в тело запроса в виде req.user.
Таким образом, этот пользователь будет содержать идентификатор
конкретного пользователя, который фактически публикует этот комментарий.
Таким образом, мы уже проверили подлинность пользователя,
и поэтому идентификатор пользователя можно просто получить, сказав req.user.
_ID, и идентификатор этого пользователя,
я назначу это поле автора из комментария.
Теперь, когда комментарий приходит,
комментарий в теле сообщения запроса будет
содержать только поле рейтинга и поле комментария.
Теперь мы не хотим явно отправлять поле автора со стороны клиента,
вместо этого это должно быть автоматически вставлено
на стороне сервера на основе подлинности
пользователя. Вот тот момент, который я
повторял в этой модификации, что я сделал здесь.
Таким образом, информация о пользователях автоматически получает от req.user, который
загружается в тело сообщения запроса пользователем проверки подлинности,
который будет использовать Passport authenticate со стратегией JWT там.
Кроме того, теперь, когда мы получаем обновленное блюдо здесь,
нам нужно заполнить авторскую информацию в блюдо.
Итак, в этот момент,
когда мы получаем блюдо здесь,
мы будем искать блюда здесь.
Итак, мы скажем Dishes.FindByID,
а затем
поставим идентификатор блюда в качестве параметра здесь, так что мы скажем, найти по
ID, блюдо ID, а затем,
нам нужно заполнить комментарии автора здесь,
а затем мы скажем, блюдо.
Внутри, мы отправим эту информацию о блюде пользователю здесь.
Так что, позвольте мне вырезать это и вставить его сюда.
Таким образом, эта модификация необходима, потому что теперь мне нужно заполнить
информацию автора обратно
в комментарий, прежде чем я смогу отправить текущее обратно пользователю.
Итак, это дополнительная модификация, которую нам нужно
сделать, когда мы используем популяцию Мангуста здесь.
Точно так же, теперь идя в пут,
когда мы изменяем конкретный комментарий с идентификатором комментария,
так что это под блюдо ID комментариев части.
Итак, когда мы делаем положить здесь,
поэтому мы сначала находим блюда найти по id req params блюдо ID,
затем в блюдо.
Итак, первое, что мы проверяем, это убедиться, что если блюдо не является нулевым,
а идентификатор комментариев блюда не равен нулю,
поэтому мы проверили, чтобы убедиться, что комментарий действительно присутствует в блюде,
а затем, когда само блюдо возвращается,
то нам нужно снова искать
блюдо, потому что нам нужно заполнить комментарии автора в блюдо.
Итак, здесь мы скажем Dishes.FindByID (dish ID),
причина, по которой нам нужно сделать еще один поиск, заключается в том, что
нам нужно заполнить comments.author здесь,
так что это единственная причина, почему нам нужно сделать еще один поиск здесь.
Затем, когда мы получаем блюдо здесь,
очевидно, потому что мы только что обновили блюдо, так что информация о блюде должна быть
найдена в базе данных, так что должны работать нормально, а затем внутри будет говорить
код риска 200 res установить заголовок типа приложения json,
а затем вернуть блюдо здесь,
а затем мы будем обрабатывать ошибку здесь,
а затем другие, если блюда
сейчас, а также другие ошибки, которые мы установили ранее,
они будут обрабатываться как обычно здесь.
Итак, это дополнительные изменения, которые мы должны убедиться, когда вы обновите блюдо,
когда вы отправляете обратно обновленный комментарий или обновленное блюдо,
то мы заполним комментарий в блюдо здесь.
Аналогичным образом, перейдя к
удалению здесь, а затем после удаления комментария,
снова мы собираемся получить блюдо и заполнить информацию автора.
Итак, позвольте мне просто скопировать эту часть,
а затем мы будем делать точно то же самое здесь,
поэтому мы скажем блюдо сохранить,
затем мы будем проверять Dish.FindByID (автор блюда),
а затем мы заполним автора комментариев,
а затем мы скажем (затем) блюдо,
а затем res.StatusCode, и так далее,
а оставшаяся обработка ошибок, как и прежде.
Итак, с этой модификацией в блюдо роутер,
теперь последний момент, который мы должны учитывать, это тот факт, что в файле user.js
мы теперь добавили в поля
имя и фамилию поля, которые по умолчанию будут пустыми строками.
Таким образом, когда пользователь регистрируется,
мы должны позволить пользователю указать имя и
фамилию в процессе регистрации.
Теперь, где это происходит?
Это происходит в пользователей.js.
Итак, перейдя к пользователям users.js,
когда пользователь публикует на рассылке косой черты,
ранее мы только размещали имя пользователя и пароль.
В дополнение к этим двум,
в объекте json, который мы включаем в тело сообщения запроса, поступающего в
сообщение с запросом, поступающее со стороны клиента,
мы также можем включить имя и фамилию пользователя.
Итак, когда имя и фамилия пользователя включены,
так что мне здесь делать?
Итак, помните, что когда вы говорите user.register в этот момент, информация о пользователе приходит,
а затем вы отправили имя пользователя здесь,
и вы также назначили пароль здесь, который будет
превращен в хэш и соль паспортом локального мангуста.
Теперь, если нет ошибки, это означает, что регистрация пользователя была успешной,
и поэтому в этот момент мы будем делать, мы скажем, если req.body.
Имя. Итак, что означает, что тело входящего сообщения запроса,
если оно содержит имя,
то мы скажем user.firstname равно req.body.firstname.
Аналогично, для фамилии также.
Таким образом, на данный момент
у нас будет пользователь, доступный здесь.
См. Пользователь входит в качестве второго параметра этой функции обратного вызова здесь.
Итак, мы настраиваем имя, изменяя
свойство первого имени внутри пользовательского документа здесь, говоря: req.body.firstname.
Если он существует, то мы установим имя пользователя на это.
Аналогично, если доступно имя req.body.flaw,
поэтому мы также обновим фамилию пользователя как req.body.lastname.
И как только мы сделали эти два изменения в имя и фамилию,
то нам нужно сохранить изменения, которые мы сделали для пользователя.
Итак, мы только что обновили пользователя.
Итак, мы скажем user.save, тогда это
вернет ошибку или пользователя.
Итак, если модификация была сохранена правильно,
то она вернет ошибку,
иначе она вернет значение пользователя и этот паспорт аутентифицировать мы
сделаем это внутри этого пользователя здесь.
Итак, скажем, user.save (err, user).
А затем нам также нужно перепроверить, чтобы убедиться, что
если есть ошибка в сохранении изменений пользователю,
то мы скажем res код состояния 500,
поэтому позвольте мне скопировать это оттуда.
Итак, мы скажем код статуса res 500,
res устанавливает тип содержимого заголовка приложения json и res.jason здесь.
Тогда, и мы вернемся к этому моменту.
Если ошибки нет,
то, конечно, вы аутентифицируете пользователя, вызвав
паспорт аутентифицироваться с локальным, чтобы убедиться, что
регистрация пользователя прошла успешно, и это должно быть
сделано правильно, и в этом случае вы вернете это сообщение обратно на стороне клиента.
Нам нужно закрыть этот user.save здесь.
Таким образом, убедитесь, что вы правильно закрыли эту конечную точку.
Итак, user.save закрыт здесь, и все.
Это изменения, которые нам нужно внести для пользователя.
Таким образом, после того, как пользователь зарегистрирован с данным именем пользователя и данным паролем,
затем после того, как пользователь успешно зарегистрирован,
то мы установим поле
имени и фамилии документа пользователя, используя эти два здесь.
Мы хотим убедиться, что пользователь успешно
зарегистрирован перед отправкой имени и фамилии для этого.
Поэтому мы проводим эту операцию после
успешной регистрации пользователя. Вот оно.
Давайте сохраним изменения и пойдем и проверим сервер.
После сохранения изменений
давайте теперь перейдем к терминалу, а
затем, прежде чем я запускаю сервер,
позвольте мне сначала проверить мой MongoDB и удалить пользователя, который мы зарегистрировали ранее.
Итак, мы скажем, используйте путаницу, а затем мы скажем db.usersfind.
Таким образом, мы знаем, что этот конкретный пользователь был зарегистрирован ранее,
но когда
мы регистрируем этого пользователя, мы не регистрировали имя и фамилию пользователя.
Итак, я собираюсь удалить этого пользователя, а затем повторно зарегистрировать пользователя.
Итак, чтобы сделать это с помощью пульсации Mongo, я скажу, что пользователи db падают,
а затем мы скажем,
что пользователи db находят, и это должно вернуть пустой.
Там нет пользователей, и тогда мы выйдем из пульсации Монго.
Итак, как только мы удалили этого зарегистрированного пользователя
, позвольте мне запустить свой сервер.
И как только сервер будет запущен,
давайте перейдем к Почтальону, а затем зарегистрируем
нового пользователя вместе с именем и фамилией пользователя.
Затем, они войдут в качестве этого пользователя, а затем мы посмотрим, как
население Mongoose помогает нам заполнить информацию
о пользователе автоматически в документ там.
Теперь, перейдя в
почтальон, позвольте мне зарегистрироваться нового пользователя.
Итак, я делаю сообщение localhost: 3000 пользователей регистрируются.
В теле сообщения
у нас было имя пользователя и пароль уже там.
Позвольте мне добавить два дополнительных поля:
имя, фамилия.
Затем зарегистрируйте этого пользователя.
Итак, как только я зарегистрирую пользователя,
вы увидите, что регистрация прошла успешно.
Теперь позвольте мне войти в систему как этот пользователь.
Итак, чтобы войти в систему как пользователь,
позвольте мне сделать сообщение и перекрестную проверку, чтобы убедиться.
Итак, я делаю сообщение для входа пользователей.
Позвольте мне проверить, и я вижу, что имя пользователя и пароль правильно введены там.
Поэтому, когда я вхожу в систему,
я должен быть успешно зарегистрирован, и я должен иметь возможность получить этот токен там.
Потому что этот токен имеет важное значение для нас, чтобы иметь возможность добавить блюдо на наш сайт сервера.
Итак, после того, как вы получите токен,
скопируйте эту строку токена и сохраните ее, потому что вам понадобится это в
заголовке авторизации для
операций post put и delete, которые вы собираетесь выполнить позже.
Так что позвольте мне скопировать этот жетон.
Теперь, как правило, я бы сохранил эти токены
, я просто открою текстовый документ, а затем скопирую и вставьте его в текстовый документ.
Таким образом, для последующих запросов почтальона
я могу просто скопировать эту строку, а затем вставить ее
в заголовок авторизации, если это необходимо.
Итак, позвольте мне скопировать этот токен, и здесь у меня есть текстовый документ, открытый здесь.
Итак, я собираюсь вставить эту строку в этот текстовый документ.
Итак, здесь у нас есть токен, который мы получили.
Давайте теперь пойдем и разместим блюдо на нашем сервере.
Возвращаясь к почтальну,
позвольте мне отправить блюдо на сервер.
Итак, вот где я выберу пост здесь.
Внутри здесь у меня есть информация о блюде, которую я использовал ранее, но для комментариев,
теперь, напомним, что ранее у нас было поле автора, которое хранило строку.
Таким образом, все эти комментарии недействительны.
Итак, я собираюсь удалить все эти комментарии из представления, потому что
теперь мы ожидаем, что пользователь будет публиковать комментарии самостоятельно.
Когда пользователь отправляет комментарии,
мы автоматически добавим идентификатор пользователя в поле автора комментариев.
Итак, позвольте мне разместить это блюдо здесь.
Перейдя к заголовку,
в заголовке авторизации, я собираюсь сказать, на
носителя, а затем вставить токен, а затем отправить.
Я должен сделать сообщение об этом.
Итак, я скажу сообщение, и поэтому, когда я отправлю сейчас,
вы видите, что это блюдо было опубликовано на стороне сервера,
и массив комментариев в данный момент пуст.
Итак, после того, как я отправлю это блюдо,
позвольте мне скопировать идентификатор этого блюда.
Итак, позвольте мне скопировать этот идентификатор для блюда, потому что мне
нужно, чтобы оставить комментарии к этому блюду.
Затем, перейдя в текстовый редактор,
я собираюсь сохранить этот идентификатор блюда здесь.
Теперь, конечно, как только вы создаете свою клиентскую сторону,
ваш клиент автоматически получит всю эту информацию.
Таким образом, ваш клиент автоматически сможет отправить токен и так далее.
Так что вам не нужно делать эту штуку, но с почтальоном
это единственный способ добавить любую информацию в наши запросы почтальона,
которая отправляется от почтальона на сервер.
Теперь, чтобы убедить себя в том, что это блюдо действительно существует,
позвольте мне получить на местный хозяин: 3000/блюда.
Когда я делаю get, вы можете увидеть, что
это конкретное блюдо существует на стороне сервера.
Итак, давайте теперь попробуем оставить комментарий.
Итак, чтобы опубликовать комментарий,
давайте сделаем сообщение, и мы скажем,
localhost: 3000/блюда, косая черта и идентификатор блюда, которое
я только что скопировал, и косая черта комментарии.
Когда вы размещаете на комментариях,
вам нужно убедиться, что в теле мы добавим в комментарий здесь.
Итак, типичный комментарий содержит
оценку, скажем,
пять, а затем комментарий.
Итак, позвольте мне просто ввести какой-то случайный комментарий,
просто чтобы продемонстрировать вам.
Таким образом, это должно быть в теле сообщения для комментариев и в заголовке,
мы должны добавить заголовок авторизации.
Итак, для заголовка авторизации, скажем, носитель.
Мне нужно вставить токен здесь,
вставив значение токена, которое я сохранил ранее.
Давайте теперь оставим этот комментарий.
Затем, когда комментарий опубликован,
давайте посмотрим на возвращаемое значение здесь.
Таким образом, когда вы просматриваете вниз,
вы можете увидеть, что блюдо, к которому был добавлен комментарий, было возвращено.
Обратите внимание, что информация о блюде есть, но обратите внимание, в частности,
что содержится в комментарии, который был опубликован здесь.
Таким образом, как вы можете видеть, вы уже знаете, что обновленные и
созданные в полях автоматически добавляются mongoose.
Рейтинг и комментарий, который мы представили, находятся
прямо там, но обратите внимание, как поле автора
теперь содержит идентификатор, соответствующий пользователю.
Теперь, как мы видели в коде, как добавляется информация о поле автора, теперь,
если вы сделаете попадание на блюда,
вы заметите, что это поле автора будет
автоматически заполнено информацией пользователей здесь.
Итак, давайте теперь сделаем get на локальном хосте: 3000/блюда.
Итак, когда мы сейчас делаем на этот момент,
вы заметите, что в блюдах здесь,
прямо там, информация о блюде уже
присутствует, но обратите внимание, как комментарий теперь построен.
Комментарий теперь содержит,
поля рейтинга комментария, как мы видели ранее,
обновленные и созданные на,
но обратите внимание, что произошло с полем автора здесь.
Таким образом, когда вы делаете запрос get, потому что мы сделали заполнение на
стороне сервера при вызове операции get,
заполнение автоматически заполняет
информацию автора в позицию в поле автора здесь.
Таким образом, там вы можете видеть, что от автора
теперь вы можете искать фамилию и
имя информацию автоматически из поля автора.
Итак, если вам нужно построить комментарий,
то теперь у вас есть рейтинг
, комментарий, а также имя и фамилия
автора автоматически включаются в этот документ.
Кроме того, имя пользователя также включено в этот документ.
Таким образом, вы можете добавить информацию из другого документа и заполнить
второй документ этой информацией, прежде чем отвечать с сайта сервера.
Таким образом, это использование популяции мангуста и как мы
можем автоматически заполнить информацию в документ мангуста.
С этим мы завершаем это упражнение.
В этом упражнении мы видели использование популяции мангуста, и мы также видели,
как мы можем заполнить информацию из одного документа в другой документ. Таким образом
, когда мы модифицируем сервер, чтобы сделать население для запросов,
mangoose автоматически позаботится о заполнении этой информации для нас.
Все, что нам нужно сделать,
это сохранить ссылку на другой документ в виде идентификатора объекта,
в документ, в который вы хотите заполнить эту информацию.
С этим мы завершаем это упражнение.
Это хорошее время для вас сделать git-commit с сообщением, популяцией мангуста.