Ya habíamos desarrollado un servidor API REST completo
usando Express y MongoDB como parte de este curso.
Para que ese servidor pueda comunicarse de manera significativa con nuestro cliente,
haremos algunos ajustes menores para que
devuelva el tipo correcto de datos para que
nuestra implementación del cliente pueda trabajar de
manera más eficiente con los datos devueltos desde nuestro sitio de servidor.
Por lo tanto, para hacer eso,
trabajemos en algunos ajustes en nuestro sitio de servidor en este ejercicio.
Antes de comenzar este ejercicio,
supongo que no ha hecho
la lección anterior sobre la integración del cliente angular y
el servidor porque está haciendo esta lección a través de la especialización React.
Por lo tanto, los cambios que haré en el servidor supondrán que
la versión del servidor que está modificando es anterior a la lección anterior.
En caso de que haya realizado esa lección en el cliente angular,
algunos de los cambios que ha hecho en el servidor se repetirán de nuevo
en este ejercicio para que pueda omitir esa parte de los cambios.
Entra a nuestro servidor en el editor.
Antes de comenzar a trabajar en el servidor,
le sugiero que descargue todas las imágenes que he
proporcionado como un archivo zip en los recursos del ejercicio llamados images.zip.
Descomprima el archivo y luego obtenga todas las imágenes desde allí y luego copie esas imágenes
en la carpeta de imágenes públicas en nuestro servidor.
Por lo tanto, ven que aquí he copiado todas las imágenes en mi carpeta de imágenes públicas aquí
ya porque nuestro servidor es el que va
a servir todas estas imágenes para nuestra aplicación cliente.
A continuación, vamos al CORS y ajustamos la lista blanca aquí.
Por lo tanto, para nuestra aplicación cliente React,
si comenzamos con el comando yarn start,
se ejecuta en el nombre de su computadora: 3001.
Por lo tanto, cualquier solicitud que llegue desde nuestra ubicación
al servidor llevará eso como el origen allí.
Así que es por eso que voy a agregar eso a mi lista blanca para que
cualquier problema CORS se aborde automáticamente.
Entonces, al entrar en el archivo cors.js en mi lista blanca aquí,
permítanme agregar el
nombre de la computadora http://my: 3001 y este es
el origen desde el cual mi cliente
originará las solicitudes que vienen a este servidor.
Por lo tanto, de esa manera mi CORS no causaría problemas a mi cliente.
A continuación, necesitamos actualizar algunas de las rutas para
manejar los parámetros de consulta y también algunos otros ajustes menores.
Permítanme comenzar con el archivo promoRouter.js.
Eso es fácil de actualizar.
Entonces, entrando en el archivo promoRouter.js,
en el archivo PromoRouter para la solicitud get que obtenemos
aquí en lugar de hacer promociones encontrar con un objeto JavaScript vacío,
aquí proporcionaría el req.query como parámetro para las promociones encontrar aquí,
lo mismo con el enrutador líder también.
Entonces, déjame ir al archivo leaderRouter.js.
En el enrutador líder también,
aquí donde encontrará Leaders.Find con el objeto JavaScript vacío en su lugar
reemplace eso con el req.query para que los parámetros de consulta se pasen.
Entonces, aquí es donde pasaremos la característica: true como parámetro de consulta aquí.
Ahora, después de haber ajustado estos dos,
ahora trabajemos en el enrutador de platos.
Por lo tanto, vaya al archivo dishRouter.js,
incluso en el enrutador de plato también la misma actualización aquí.
Por lo tanto, vaya a estos platos.Encuentre en el método get aquí,
cambie eso a req.query.
Entonces, con esto, mi actualización del enrutador de platos se ha completado.
Por lo tanto, ahora hemos actualizado el enrutador promocional, el líder
y el enrutador de plato,
luego pasaremos a actualizar el enrutador favorito.
Ahora, habría implementado el router favorito como parte de su cuarta asignación.
Ahora, en el enrutador favorito,
verá que para el enrutador favorito,
no le estoy mostrando la parte restante porque
debería haber hecho como parte de su asignación.
Primero, permítanme llamar su atención sobre el método get para Favoriterouter.route:DISHID.
Ahora voy a usar este método get para verificar que
el plato específico con el ID del plato ya sea un favorito para el usuario.
Entonces, en lugar de simplemente decir getoperation.supported,
solo voy a aprovechar la presencia de esta operación get y luego diremos,
Favorites.Findone y diremos usuario: req.user. _id
Por lo tanto, vamos a encontrar los favoritos para ese usuario en particular y luego vamos a decir luego
favoritos y atrapar el error siguiente.
Entonces, de manera similar aquí, vamos a añadir en el error aquí, el siguiente error aquí.
Entonces, dentro de esto entonces,
cuando obtengamos los favoritos,
entonces verificaremos si no los favoritos.
Por lo tanto, si no hay favoritos para
este usuario, obviamente el plato que estamos comprobando no existe, por
lo que devolveremos res.statusCode 200,
setHeader, Content-Type,
application/json y luego volveremos diciendo que existe false.
Lo que estamos especificando aquí es que si llegan se hace hasta este punto final con un ID de plato,
esta bandera existe aquí se establecerá en verdadero si este plato es parte de mis favoritos.
Si este plato no es parte de mis favoritos,
estableceré que existe bandera en falso.
Así que aquí, ves que dado que no tengo ningún favorito, así que
existe debería ser automáticamente falso en este punto.
Entonces, diremos que existe falso y luego devolveremos los favoritos aquí.
Bueno, obviamente, en este caso los favoritos serían nulos en este punto.
De lo contrario, lo que significa que los favoritos no es nulo,
así que vamos a decir si Favorites.Dishes.IndexOf.
Así que vamos a estar buscando a Req.Params.Dishid.
Por lo tanto, vamos a buscar esta matriz de platos favoritos para
ver si este plato existe allí y si no existe,
obviamente esto devolverá un índice negativo aquí.
En ese caso también,
volveré exactamente lo mismo que aquí.
Por lo tanto, si devuelve un índice negativo entonces eso significa que
aunque este usuario en particular tiene un conjunto de favoritos,
este plato específico no existe en
la lista de sus favoritos, por lo que devolverá existe falso aquí.
Ahora, de lo contrario eso significa que el plato existe en la lista de favoritos.
Por lo tanto, en este caso,
voy a devolver el código de estado 200 existe es verdadero.
Así, cuando el usuario realiza una operación get en este extremo con
el /Favorites/Dishid donde se suministra el Id de plato
como el parámetro aquí, como el parámetro de solicitud aquí,
entonces comprobaremos si ese plato existe en los favoritos.
Si ninguno de los favoritos existe para este usuario, entonces devolveremos un false.
Del mismo modo, si los favoritos existen pero
ese plato en particular no existe en los favoritos, entonces devolveremos false, de
lo contrario devolveremos true.
Así que esta bandera existe puede ser utilizada por mi cliente para comprobar si este plato es
parte de la lista de platos favoritos para este usuario o no.
También mientras estamos en favoritos,
cada vez que hacemos cambios en los favoritos,
queremos poder rellenar la información del usuario y los platos,
los favoritos, antes de regresar.
Por ejemplo, en el post que hacemos,
cuando guardamos los favoritos a continuación, en este punto,
nos gustaría hacer primero favoritos.
FindById, así que como acabamos de hacer los cambios
diremos favorite_id y rellenaremos tanto el usuario como también
los platos en los favoritos.
Luego, cuando se devuelvan los favoritos,
devolveremos esos favoritos en su lugar.
Así que, permítanme hacer este cambio aquí.
Por lo tanto, vamos a cortar esto desde aquí y luego dentro del entonces,
vamos a devolver los favoritos.
Después de guardar los favoritos,
entonces lo buscaremos,
para el FavoriteByID y luego devolveremos
ese favorito aquí, así que diremos luego código de retorno y estado favorito.
Este cambio debemos hacer.
Si ya ha implementado esto en sus favoritos,
entonces no necesita realizar este cambio.
Pero lo que estamos haciendo es que cada vez que hacemos cambios en los favoritos,
rellenaremos tanto la información del usuario como de los platos y luego devolveremos este valor
porque nuestro cliente React espera que esto esté allí.
Ahora, el mismo tipo de cambio,
tendremos que hacer la variable b, guardar los cambios.
Así que en la publicación aquí,
haremos un cambio a eso,
así que diremos favorites.save y luego haremos Favorites.findById y haremos ese cambio.
Del mismo modo, debajo de la identificación del plato
, también en el post,
será de manera similar, cada vez que haga cambios en los favoritos,
primero buscará y luego rellenará tanto el usuario como los platos y luego devolverlo,
y luego de manera similar en la otra parte.
Por lo tanto, debe haber implementado esto en su cuarta asignación.
Por lo tanto, haga este cambio adicional donde rellenará
el usuario y los platos antes de devolver el valor.
También con la eliminación,
haremos los mismos cambios aquí.
Por lo tanto, nota que en la eliminación,
ya he hecho este cambio aquí.
Por lo tanto, después de guardar los cambios en los favoritos,
buscaremos los favoritos y luego
regresaremos después de rellenar tanto el usuario como los platos y los favoritos.
Esto es lo que nuestro cliente React espera que hagamos.
Por lo tanto, incluso para la eliminación,
haremos los mismos cambios.
Ahora, con esto, mi enrutador favorito se actualiza,
así que procederemos a actualizar users.js a continuación.
Finalmente, actualizaremos el archivo users.js.
Ahora, en el archivo users.js necesitamos agregar
otro campo router.options aquí,
porque a veces una solicitud de publicación como vio
con el inicio de sesión enviará las opciones primero para verificar,
especialmente con los coches, si se permitirá la solicitud de publicación.
Así que es por eso que revisaremos el curso con opciones aquí y luego
simplemente devolveremos
un mensaje
de estado de 200 en respuesta a eso.
Para cualquier endpoint bajo los usuarios si recibimos las opciones,
simplemente devolveremos un estado 200 aquí.
Ahora la función de inicio de sesión que
habíamos implementado anteriormente, simplemente habíamos hecho passport.authenticate
local aquí y el comprobamos los valores restantes aquí.
Ahora, este passport.authenticate local,
si el usuario no se autentica,
simplemente devuelve un mensaje no autorizado en el mensaje de respuesta.
Ahora eso puede no ser muy significativo para el lado del cliente para mostrar esta información,
por lo que vamos a mejorar
este método de inicio de sesión después del enrutador para
que la autenticación devuelva información más significativa en este punto.
Así que para hacer eso,
no vamos a hacer el passport.authenticate aquí, en
lugar de eso vamos a tomar.
Entonces, déjame eliminar eso desde allí y luego verás
cómo actualizaré la publicación del enrutador aquí.
Por lo tanto, vamos a ver curso con opciones y luego vamos a incluir el req,
res y siguiente aquí.
Dentro de este req, res y el siguiente aquí,
passport.authenticate llamará a esto con local.
Ahora, cuando llamamos a esto con local,
si se produce un error de autenticación, se
puede hacer que el passport.authenticate devuelva
el valor del error y también devolverá al usuario si
no hay error y un tercer parámetro llamado info
que llevará información adicional que podría ser analizada de nuevo a el usuario.
Este error se devolverá cuando se
produzca un error genuino en passport.authenticate.
Pero si la información del usuario
se envía a passport.authenticate pero el usuario no existe,
entonces eso no se cuenta como un error.
En su lugar, se contará ya que el usuario no existe y
esa información se analiza de nuevo en el objeto info que entra.
Por lo tanto, el error se devolverá cuando haya
un error genuino que ocurre durante el proceso de autenticación,
pero la información contendrá información si el usuario no existe.
Por lo tanto, passport.authenticate está devolviendo un mensaje diciendo que
el usuario no existe o que el nombre de usuario
es incorrecto o la contraseña es incorrecta, etc.
Por lo tanto, esa información será transmitida en el mensaje de información.
Ahora veremos cómo esto es útil para
nosotros cuando miramos el lado del cliente un poco más tarde.
Entonces, en esta situación,
manejaremos esto de la siguiente manera,
y no solo eso cuando llamamos a este passport.authenticate,
también necesitamos pasar un req,
res, al lado de los tres parámetros a él.
Por lo tanto, esta es la estructura cuando necesita llamar a passport.authenticate y esperar que
le transmita información como esta como un método de devolución de llamada aquí,
por lo que también necesita proporcionar este req, res, el
siguiente justo allí también.
Ahora, si esto ocurre,
entonces diremos si err,
así que si ocurre un error,
diremos que devuelve el siguiente error y luego dejemos que
el manejador de errores de nuestro router express y se encargue de eso.
Ahora, consideraremos otras situaciones, si no el usuario.
Por lo tanto, si hemos llegado a este punto,
entonces eso significa que no fue un error que ocurrió
, sino que quizás el usuario no pudo ser encontrado.
Si no se encuentra el usuario,
entonces el usuario aquí se establecerá como nulo en este caso.
Por lo tanto, en esa situación,
si el usuario no existe,
entonces necesitamos poder pasar información de vuelta al lado del servidor.
Entonces, lo que haremos es pasar esta información en este formato.
Así que, voy a cortar esto desde aquí y
luego pegarlo aquí y luego editaremos esto.
Por lo tanto, si el usuario es nulo,
entonces enviaremos un código de estado como 401 lo que significa
no autorizado y luego devolveremos la información de éxito falso,
y luego no vamos a pasar de nuevo el token,
vamos a pasar de nuevo el mensaje de estado.
Por lo tanto, aquí vamos a decir
'Iniciar sesión sin éxito' y luego la tercera información,
vamos a pasar esta información ese objeto que hemos recibido aquí como
la tercera parte en el mensaje de respuesta que enviamos de vuelta desde nuestro servidor aquí.
Por lo tanto, el indicador de éxito se establecerá en falso,
el estado se establecerá Iniciar sesión sin éxito y
la información de error que se pasa en la información se volverá a transferir.
Ahora, tenga en cuenta que esta situación ocurrirá si
el nombre de usuario y la contraseña son incorrectos,
por lo que esto no es un error en el sentido del error, pero
el hecho de que el autenticado no pudo encontrar el usuario o la contraseña del usuario es incorrecto.
Por lo tanto, esa información se codificará en la información que entra y así voy a
pasar de nuevo como un error al lado de mi cliente.
La parte de lo contrario
se maneja como req.login.
Por lo tanto, si esto es exitoso,
el passport.authenticate vamos a añadir este método llamado req.login al usuario.
Por lo tanto, en este punto,
simplemente pasaremos el objeto de usuario que hemos obtenido.
Así que aquí, si hemos llegado a este punto,
entonces eso significa que el objeto de usuario no es nulo y tampoco se produjo ningún error,
por lo que significa que el usuario puede iniciar sesión.
Entonces, diremos err,
intentaremos iniciar sesión con el usuario.
Por lo tanto, diremos si err y
luego pasaremos el mismo tipo de información de error que hicimos aquí.
Así que en este caso, si hay error,
entonces pasaremos un código de estado como 401 y diremos que el éxito
es falso y el estado como Inicio de sesión no exitoso,
y luego la información del error,
en lugar de la información,
pasaremos en 'No se pudo iniciar sesión en el usuario».
Por lo tanto, ese es el mensaje que pasaremos aquí si se produce el error.
De lo contrario, estaríamos abajo aquí abajo.
Entonces, en este punto,
seríamos capaces de generar el token.
Por lo tanto, si hemos llegado hasta este punto,
eso significa que el usuario ha iniciado sesión con éxito,
por lo que ahora podemos generar el token.
Por lo tanto, generaremos el token basado en el ID del usuario,
y luego devolveremos el token al usuario.
Entonces, aquí, diremos token var,
y luego podemos decir Res.statusCode es 200 y luego res.json verdadero éxito,
por lo que, lo que significa que el usuario inició sesión con éxito.
Por lo tanto, el estado sería el inicio de sesión exitoso.
Luego, la tercera parte,
en lugar del error,
volveré a pasar el token al usuario.
Entonces, diremos token,
este token que acabamos de obtener antes.
Por lo tanto, ese token se pasará como la propiedad token del mensaje de respuesta.
Por lo tanto, aquí, observe que el éxito se establece en verdadero, por lo
que, lo que significa que el usuario inició sesión con éxito,
y por lo tanto, el usuario puede continuar más allá en este punto.
Esto tiene que hacerse dentro del req.login aquí.
Por lo tanto, en este punto,
cerraremos el req.login.
Por lo tanto, observe que esto está dentro de este req.login aquí.
Así que, ahí dentro, pasaremos estos tres de vuelta.
Así que, déjame sangrar estas tres líneas.
Entonces, así es como manejaríamos el método de registro del usuario.
Entonces, de nuevo, revisando este código una vez más.
Por lo tanto, haremos la publicación del enrutador,
pero en lugar de hacer la autenticación del pasaporte justo allí
, diremos req, res
, siguiente, y luego dentro de aquí,
haremos una autenticación de pasaporte para el local,
y esta autenticación pasará de nuevo.
Por lo tanto, podemos proporcionar una función de devolución de llamada a eso,
y esta función de devolución de llamada devolverá
el error, el usuario o la información aquí.
Por lo tanto, si se trata de un error,
permitiremos que el manejador de errores expresos se encargue de eso.
Si el usuario es nulo,
entonces eso significa que el inicio de sesión del usuario no tuvo éxito,
y el motivo de eso estará en la información.
Por lo tanto, eso pasará como el error de información en el mensaje de respuesta aquí.
Si llegamos a este punto,
entonces el usuario se verifica con éxito.
Entonces, iniciaremos sesión al usuario.
Por lo tanto, el pasaporte se autentica,
vamos a agregar en este método llamado inicio de sesión a la req, el mensaje de solicitud.
Por lo tanto, podemos llamar al inicio de sesión con el usuario.
Si esto devuelve un error,
entonces devolveremos el error aquí apropiadamente.
Si no, habremos llegado al punto en el que el usuario se autentica con éxito.
Por lo tanto, podemos generar el token web JSON aquí y luego devolver
el token web JSON al usuario para confirmar que el usuario ha iniciado sesión correctamente.
Por lo tanto, ese es el conjunto de pasos que vamos a usar aquí.
Ahora, la razón por la que hago una forma más elaborada de manejarlo es que
quiero distinguir entre la situación en la que
ocurre un error genuino durante el proceso de autenticación en lugar de la situación en la que
el nombre de usuario no es válido o la contraseña no es válida.
Por lo tanto, esos dos casos serán manejados por esta situación,
donde la información nos llevará la información de vuelta.
Por lo tanto, eso no es un error per se,
pero esa es una situación en la que el usuario
no es un usuario válido o la contraseña del usuario no es válida.
Entonces, así es como manejaremos el proceso de inicio de sesión del usuario.
Además, agregaré un
método más aquí llamado CheckJWTToken.
Es muy posible que mientras el cliente haya iniciado sesión y obtenga el token web JSON, en
algún momento más tarde, el token web JSON puede caducar.
Por lo tanto, si el usuario intenta acceder desde el lado del cliente con un token caducado al
servidor, entonces el servidor no podrá autenticar al usuario.
Por lo tanto, a intervalos periódicos, es
posible que desee verificar cruzada para asegurarnos de que el token web JSON sigue siendo válido.
Entonces, esa es la razón por la que estoy incluyendo esto,
otro punto final llamado CheckJWTToken.
Por lo tanto, si hace un llegar al CheckJWTToken
incluyendo el token en el encabezado de autorización,
entonces esta llamada devolverá un verdadero o falso
para indicarle si el token web JSON sigue siendo válido o no.
Si no es válido, el lado del cliente puede iniciar otro inicio de sesión para
que el usuario obtenga un nuevo token web JSON si es necesario.
Entonces, para hacer esto,
diremos cors.corsWithOptions y req,
res aquí como se esperaba.
Aquí, diremos que el
pasaporte autentica jwt
y session: false,
y esto devolvería err, usuario, info.
Por lo tanto, recuerde cómo usamos el pasaporte autenticar antes.
Entonces, llamamos al JWT con sesión falsa aquí.
Así que, antes aquí, decimos que el pasaporte autentica local.
Por lo tanto, esto es para la autenticación local.
Por lo tanto, esto es para la autenticación JSON Web Token.
Entonces, cuando llamemos a eso,
ya que eso va a verificar el token web JSON, entonces diremos,
si err devuelve el siguiente error,
y luego dejemos que el manejador de errores expresos se ocupe de esa situación.
Luego, diremos, si no es usuario,
si el usuario no existe, entonces de manera similar.
Entonces, lo que significa que si el objeto de usuario se
encontró desde el token web JSON y luego se cargó en el req.user,
entonces eso significa que el usuario es un usuario válido,
por lo que se puede permitir continuar más adelante.
De lo contrario, vamos a decir que el usuario no existe.
Por lo tanto, tenemos que informar que el JSON Web Token ha caducado.
Entonces, en este punto,
enviaremos una resolución con
un código de estado de 401.
Entonces, no autorizado, setHeader, Content-Type,
application/json, y luego devolveremos res.
Res.json dirá que el estado JWT
no es válido y luego,
devolveremos un indicador llamado éxito cae y luego,
devolveremos la información que obtenemos si el usuario
no está autenticado como el error en este punto.
De lo contrario, eso significa que llegamos a este punto,
entonces el usuario es un usuario válido.
Entonces, en este caso,
déjame copiar ese código aquí,
estaremos enviando un código de estado de 200 y luego el res.json,
enviará JWT válido y exitoso siendo verdadero.
En la tercera parte, enviaremos la información del usuario.
De esa manera, cuando se llama a este extremo con el método get
, esto verificará si el token es válido o no.
Si el token es válido,
entonces recibirá esta respuesta y desde el indicador de éxito en la respuesta,
puede verificar si el jsonwebtoken es válido o no.
Esto es útil en el lado del cliente.
Ahora, este pasaporte autenticar aquí tendrá que ser suministrado
con req y res como los dos parámetros aquí.
Entonces, así es como llamamos autenticar el pasaporte.
Por lo tanto, observe que cada vez que llame a la
autenticación de pasaporte y espere esta función de devolución de llamada aquí,
debe anexar a este punto req.res a la autenticación de pasaporte en la parte posterior aquí.
En nuestro servidor API de descanso,
habíamos implementado nuestros comentarios de tal manera que los comentarios
formaban sub-documentos dentro del documento del dishe,
por lo que compran cada plato adjunto su propio conjunto de comentarios.
Pero la forma en que implementamos nuestro cliente React es
tal que los comentarios se mantienen independientes de los platos,
y los comentarios mismos llevan el ID de plato correspondiente.
Ahora, estas son dos formas diferentes de
implementar tanto el lado del servidor como el lado del cliente.
En la aplicación Angular que estamos implementados en nuestra especialización Angular,
habíamos utilizado el método de subdocumento para
manejar comentarios en nuestra aplicación cliente Angular.
Por lo tanto, el resto del servidor API
se implementó de tal manera que era más adecuado para el cliente angular.
Pero para los clientes React, ya que mantuvimos los comentarios independientes de los platos,
y luego usamos el ID del plato dentro del comentario,
por lo que necesitamos reestructurar nuestro servidor API de descanso,
por lo que tenemos un punto final de comentario independiente del punto final de los platos.
Por lo tanto, necesitamos reestructurar nuestro código en el servidor
para introducir el punto final de la API REST /comments en esta etapa.
Entonces, para hacer eso,
sigamos adelante e implementemos un nuevo modelo llamado como comment.js.
Entonces, al entrar en los modelos,
permítanme implementar un nuevo archivo llamado comments.js.
En el archivo comments.js,
vamos a mover el CommentSchema del
archivo dishes.js al archivo comments.js y luego eliminarlo completamente del archivo dishes.js.
Pero antes de hacer eso,
necesitamos copiar la mangosta y el esquema desde aquí,
así que permítanme copiar esto de dishes.js en comment.js.
Después de eso, al entrar en dishes.js,
permítanme cortar este CommentSchema completamente desde aquí,
porque tendremos esto por separado en el modelo de comentarios aquí.
Entonces, vamos a mover eso al modelo de comentarios y luego pegarlo aquí.
Pero, por supuesto, este no es el completo,
vamos a actualizar un poco el CommentSchema.
Pero antes de hacerlo,
vuelva al archivo dishes.js y en el archivo de platos,
eliminaremos los comentarios del dishessChema,
porque vamos a almacenar el contenido por separado de
los platos en esta versión de nuestro servidor.
Entonces, así es como actualizaremos el modelo de platos aquí.
Por lo tanto, hemos eliminado los comentarios completamente del modelo de platos aquí.
Al entrar en el modelo de comentarios,
por lo que ahora vemos que tenemos el CommentSchema implementado aquí.
Pero además, en el CommentsSchema,
ahora necesitamos señalar explícitamente
el plato específico para el que este comentario es el comentario correspondiente.
Ahora, aquí es donde
nuestra población de mangostas y
la forma en que almacenamos los identificadores de objetos viene a nuestro rescate.
Por lo tanto, vamos a actualizar el CommentSchema diciendo que tendremos la calificación,
el comentario y el autor aquí.
Además del autor,
vamos a introducir un campo más llamado como el plato aquí que es
del tipo: mongoose.schema tipes.objectID,
y por lo que esto se referirá al plato aquí.
Por lo tanto, esto sería una referencia de objeto al modelo de plato aquí,
y así con esta modificación ahora
nuestros comentarios contendrán el campo de calificación, el campo de comentario,
el autor que es de nuevo una referencia al usuario correspondiente,
y luego el campo de plato que es una referencia al correspondiente plato aquí.
Entonces, lo que significa que ahora necesitaremos
rellenar los comentarios tanto con el autor como con el campo de plato.
Una vez que hayamos completado esto,
entonces diremos var Comentarios
mongoose.model y llamaremos a este 'Comentario',
y luego esto usa el CommentSchema que acabamos de definir aquí,
y luego necesitamos exportar esto desde aquí,
el comments.model desde aquí.
Por lo tanto, ahora que hemos introducido el comments.model,
entonces vamos a seguir adelante y luego introducir un nuevo Router llamado CommentRouter.
Entonces, para introducir el enrutador de comentarios,
vayamos a las rutas aquí
y luego creemos un nuevo archivo llamado commentRouter.js.
En commentRouter.js, permítanme copiar algunas cosas
desde el DishRouter.
Por lo tanto, tendremos estos comentarios aquí,
así que permítanme copiar sobre estas cosas desde y también,
mientras estoy en ello déjeme copiar estos también hasta ese punto,
y luego lo actualizaré un poco más tarde.
Entonces, al entrar en el CommentRouter,
necesitamos todas estas partes,
por lo que diremos Com, Express, BodyParser, mangosta
, autenticar, cors, y luego
importaremos comentarios de modelos/comentarios.
Entonces llamaremos a esto como el CommentRouter, que es un Express.Router aquí.
Luego diremos que CommentRouter use BodyParser,
y luego esto ahora se convertiría en ruta CommentRouter.
Ahora, tenemos que ir al DishRouter y luego
eliminar todas las partes que se refieren a los comentarios aquí.
Por lo tanto, déjame recortar esta parte y luego reutilizaremos estos para nuestro CommentRouter.
Por lo tanto, todos estos ya no son necesarios en el DishRouter.
Por lo tanto, voy a eliminar todo esto del DishRouter aquí,
así que permítanme cortarlos,
todo lo relacionado con la ruta de comentarios del DishRouter,
luego iremos al CommentRouter,
y luego dejaremos que siga adelante y pegue eso en su lugar aquí,
luego lo editaremos aquí.
Luego, después de esto, necesitamos exportar el CommentRouter.
Por lo tanto, exportará el CommentRouter para nosotros.
Pero, por supuesto, este código no es completamente preciso.
Por lo tanto, tenemos que seguir adelante y arreglar este código aquí.
Por lo tanto, para este código,
ahora nos damos cuenta de que esta no es la ruta DishRouter,
en lugar de eso debería ser
el endpoint /endpoint porque
vamos a montar esto en el endpoint /comments aquí.
Entonces, diremos CommentRouter,
y luego las opciones CorsWithOptions (req,
res) que permanece como tal allí,
y luego el get cors.cors y luego req.res,
y luego este se convertirá en comentarios.
FindById, req.
Por lo tanto, esto sería comments.find
y req.query aquí.
Por lo tanto, cuando se encuentran los comentarios
, entonces, en este punto,
vamos a llenar el autor,
ya tenemos allí, poblar aquí.
Por lo tanto, solo voy a eliminar este comments.author, y luego,
simplemente rellenaremos el autor aquí.
Entonces, esto nos daría comentarios aquí.
Entonces, diremos, esto se puede simplificar significativamente.
Entonces, el error de captura está allí de todos modos.
Entonces, cuando llegue el comentario, simplemente regresará.
Lo siento, eso debería ser.
Por lo tanto, si para obtener,
cuando obtenemos los comentarios,
comentarios.Find req.query, .populate autor aquí,
y luego, vamos a decir, .then comentarios,
y luego, vamos a decir, res.statusCode 200,
setHeader, y luego, vamos a devolver los comentarios de aquí,
res.json comentarios desde aquí.
Ahora, no estoy llenando los platos aquí porque no necesito explícitamente
los platos de la forma en que uso esta información en mi cliente de reacción.
Solo necesito el ID del plato,
y el ID del plato ya está presente allí,
y eso es lo suficientemente bueno para usar estos datos en mi cliente de reacción.
Así que, voy a dejarlo ahí como tal.
Solo voy a rellenar
la información del autor allí porque necesitamos toda la información del autor
cada vez que representamos un elemento de comentario en nuestro cliente reaccionar.
Por lo tanto, el get se actualizará así aquí.
Para la publicación CorsWithOptions,
diremos, Authenticate.VerifyUser req, res, siguiente.
Obviamente, para que se publique un comentario,
necesita que el autor sea un usuario válido que haya iniciado sesión.
Solo entonces, permitirá que el usuario publique un comentario.
Luego, el comentario en sí viene en el cuerpo del mensaje de solicitud entrante.
Entonces, primero, revisaremos el cuerpo
para asegurarnos de que el comentario esté incluido en el cuerpo aquí.
Entonces, aquí, voy a eliminar todas estas partes, y luego,
simplificarlo aún más, y luego,
vamos a implementar esto correctamente allí.
Entonces, justo en este punto, diremos,
si req.body no
es igual a nulo, por lo que significa que hay un comentario que está encerrado dentro del cuerpo.
Así que, déjame cortar esto y mover esto a la parte if aquí,
y luego, vamos a editar eso aquí.
Entonces, si el cuerpo no existe,
entonces causaremos un error.
Por lo tanto, diremos, errr nuevo Error,
Comentario no encontrado en el cuerpo de la solicitud.
Por lo tanto, vamos a plantear este error aquí.
El estado del error es 404.
Luego, diremos, devuelve el siguiente error.
Por lo tanto, vamos a manejar la parte del error aquí si el cuerpo
no contiene la información de comentario apropiada.
Si contiene, entonces, por supuesto,
lo que haremos a continuación es,
diremos, req.body.author es req.user. _id.
La razón por la que estamos haciendo esto es que recordamos que si
es un usuario registrado y el usuario ha iniciado sesión,
entonces el req.user contendrá la información del usuario.
Por lo tanto, solo necesito el ID del usuario que está conectado actualmente.
Por lo tanto, diremos, req.user. _id y, a continuación,
estableceremos el req.body.author en req.user. _id.
Ahora, el usuario de verificación se asegurará automáticamente de que si aterriza en este punto,
obviamente tendría un usuario que ha iniciado sesión correctamente.
De lo contrario, eso ya habría causado el problema allí.
Por lo tanto, cuando llegue a este punto,
tendría un usuario válido que ya haya iniciado sesión en el sistema allí.
Así que, aquí es donde usted sería capaz de hacerlo ahora. Por
lo tanto, lo que estamos haciendo es que el campo autor,
lo estamos configurando explícitamente en el ID del usuario aquí para que
el req.body contenga las partes restantes del comentario.
Entonces, como te das cuenta, el comentario contiene la calificación,
el comentario en sí, y el autor, y los campos de plato.
Por lo tanto, las partes restantes deberían haber sido rellenadas por el usuario.
La calificación, el comentario
y la información del plato ya deben rellenarse
en el cuerpo del mensaje de solicitud entrante.
La parte del autor se deja sin llenar allí,
que insertaremos explícitamente en este punto en el cuerpo aquí.
Entonces, ahora, el req.body contendrá toda la información del comentario.
Entonces, en este punto,
en lugar de hacer esto, diremos, comentarios.Create.
Usando el req.body, vamos a crear los comentarios aquí.
A continuación, esto devolverá
el comentario correspondiente al comentario que acabamos de insertar aquí.
Ahora, una vez que el comentario ha regresado,
entonces deberíamos hacer Comments.FindById.
Ahora, la razón por la que necesitamos hacer esto es porque necesitamos
rellenar la información del autor aquí.
Entonces, diremos, comentarios de FindById. _id
y, a continuación, rellenaremos la información del autor en el propio comentario.
Entonces, diremos, luego comentar.
Ahora, obviamente, aquí, usted encontrará que el comentario
existirá porque acabamos de insertar ese comentario en su lugar allí.
Entonces, aquí, simplemente devolveremos, Res.statusCode es 200,
Res.setHeader es Content-Type, application/json.
El comentario en sí dirá, res.json, y luego,
devolverá el comentario en este punto.
Por lo tanto, esta es la forma en que manejaremos la inserción de
un nuevo comentario en nuestro lado cliente aquí.
Para poner, como te das cuenta,
no podrás hacer un put en los puntos finales /comments/.
Por lo tanto, diremos, la operación PUT no es compatible con /comments/ punto final.
Ese es el punto. Ese es el mensaje que devolverás.
Por lo tanto, StatusCode es 403,
y luego, la operación PUT no es compatible con /comments/.
Ahora, cuando hagamos una eliminación,
permítanme cortar esto desde aquí, y luego, diremos,
comentarios.Eliminar.
escrito vacío. Por lo tanto, cuando haga una eliminación en el extremo de comentarios barra diagonal,
eliminará todos los comentarios de su sistema.
Por lo tanto, esta es una operación muy peligrosa, y por lo tanto,
no debería estar haciendo esto normalmente.
Por lo tanto, solo permitiremos que el administrador realice tal operación.
Por lo tanto, eliminaremos todos los comentarios de allí.
Entonces, cuando obtenga la respuesta,
diremos Res.statusCode 200.
Así que, déjame copiar estas partes aquí,
y luego venir y pegarlas aquí.
Entonces, diremos, comentarios.remove.
Luego responda Res.statusCode 200 aplicación json y luego res.json (respuesta) aquí.
Entonces, así es como manejamos la eliminación.
Operación de eliminación en el extremo de comentarios de barra diagonal.
Ahora, la siguiente ruta es el enrutador de comentarios.
Por lo tanto, aquí diremos CommentRouter.route y
el punto final aquí sería la barra diagonal CommentID.
Entonces, aquí las opciones permanecerán como tales.
Luego, para obtener en el enrutador actual,
para el get diremos, comments.FindById (req.params.
Esto sería CommentID.
Por lo tanto, una vez que
encontremos el comentario específico, entonces rellenaremos solo el autor desde allí.
Luego, una vez que rellene el autor,
diremos, luego comentaremos.
Ahora, toda esta parte es innecesaria aquí,
así que voy a borrar la parte.
Esto tampoco es lo apropiado aquí.
Entonces, déjame cambiar el nombre del código.
Por lo tanto, diremos para obtener comentarios. FindById,
luego rellene el autor,
luego comente, Res.StatusCode es 200, setHeader.
Entonces el resto son JSON.
Simplemente devolveremos los comentarios aquí.
Por lo tanto, vamos a devolver el comentario en este punto, res.json (comentario).
Encontrará el comentario específico
y, a continuación, devolverá ese comentario para la publicación.
Para la post-operación, como se da cuenta,
la post-operación no está
permitida en comentarios CommentID.
Por lo tanto, ese es el mensaje que vamos a enviar,
operación POST no es compatible con comentarios barra diagonal CommentID.
Entonces, ese es el mensaje que diremos para el puesto.
Ahora, para el punto, diremos comentarios.Find donde Id (req.Params.CommentID).
Entonces, encontraremos el comentario allí,
y allí comentario, así que para el puesto.
Entonces, encontraremos el comentario allí,
y luego diremos por los comentarios.
Por lo tanto, si encontramos el comentario,
si el comentario no es nulo,
entonces también verificaremos si comment.author.
Si no, comment.arthur es igual a (req.user. _id).
Por lo tanto, estamos cruzando para asegurarnos de que
el comments.author sea el mismo que el usuario actual.
Sólo el usuario actual que ha iniciado sesión - si el usuario es el mismo que el autor de los comentarios,
entonces el usuario podrá actualizar.
Entonces, eso es lo primero que verificaremos.
Entonces, comentarios, luego comments.author.equal a rec.user. _id
Si no, dirás que no estás autorizado a actualizar este comentario.
Como ve.403,
y luego devuelva el siguiente error aquí.
Por lo tanto, crearemos el error allí.
Luego, después de esto, diremos
req.body.author, req.user. _id,
eso es importante.
Ahora bien, estos dos no son necesarios aquí,
porque estamos guardando directamente el comentario.
Luego píldoras, vamos a decir Comments.FindByidandUpdate,
y req.Params.CommentID.
Por lo tanto, encontraremos ese comentario específico,
porque ya se nos ha proporcionado el ID del comentario.
Por lo tanto, vamos a hacer comentarios findById req.params.commentID.
Entonces diremos entonces (comentario).
Cuando suministre el req.params.commentID,
tendremos que proporcionar explícitamente el segundo parámetro,
que es lo que queremos cambiar.
Entonces, diremos $set: req.body.
Por lo tanto, el segundo parámetro, esencialmente,
le dice qué parte está cambiando.
Ahora, ya que se nos ha suministrado el cuerpo que contiene el comentario actualizado,
vamos a actualizar todo el comentario en sí mismo.
Entonces la otra parte que vamos a pedir es nueva: verdadera.
Por lo tanto, esto asegurará que el comentario actualizado será devuelto en
el estudio de esta llamada a los comments.FindByidAndUpdate.
Entonces, diremos luego comentarios.
Cuando se devuelve ese comentario,
entonces diremos Comments.FindById (comentario. _id).
A continuación, rellene el autor allí.
Vamos a llenar el autor allí,
y luego vamos a decir luego comentario.
Por lo tanto, verá que obtendremos el comentario y luego devolveremos el comentario en este punto.
Por lo tanto, así es como vamos a actualizar el comentario.
Entonces, esta es la situación en la que el comentario no es nulo.
Por lo tanto, esta declaración if para el comentario no es nula.
Por lo tanto, el resto si parte,
ahora esto no es aplicable,
así que diremos otra cosa, error.
El error en este caso.
Por lo tanto, si el comentario es nulo,
eso significa que no encontramos el comentario allí,
por lo que no puede modificar un comentario inexistente.
Así que vamos a decir err,
nuevo comentario de error req.params.commentid no encontrado y luego devolveremos el error.
Entonces, así es como manejaremos la parte puesta de nuestro comentario aquí,
y luego finalmente la eliminación.
Para la eliminación, nuevamente tendremos que encontrar primero
comments.findById (req.params.commentID)
y luego comentar.
Por lo tanto, vamos a buscar el comentario.
Por lo tanto, primero verificaremos si el comentario no es igual a nulo.
Eso es importante comprobarlo aquí.
Luego, la siguiente parte que comprobaremos es si comment.author es igual a req.user. _id.
Nos aseguramos de que este usuario que está tratando de eliminar
este comentario sea exactamente el mismo usuario que insertó el comentario en primer lugar.
Si no, así que si esta es la situación
, verá «¡No está autorizado a eliminar este comentario!»
Y luego devuelve el estado allí.
Luego abajo aquí,
diremos Comments.FindByIDandRemove aquí.
Por lo tanto, diremos Comments.FindByIDandRemove (req.Params.CommentID),
luego obtendremos alguna respuesta del comentario.
Entonces, en este punto,
simplemente diremos, Res.statusCode.
Entonces diremos Comments.findByidandRemove luego respuesta.
Si se elimina correctamente,
diremos 200 y luego res.json
respuesta aquí y también detectaremos el error en este punto.
Así que, déjame copiar eso aquí y luego incluiremos la captura del error en este punto.
Así que, eso es lo primero que comprobaremos.
Nos aseguraremos de que el comentario no sea igual a nulo.
De lo contrario, así que esta es la parte más.
Por lo tanto, esta es la parte más del
nuevo comentario if else req.params.commentid no encontrado y luego
404 y enviar la parte de lo demás para nosotros y luego la parte entonces manejará apropiadamente.
Entonces, estos son los cambios que hacemos para el enrutador de comentarios aquí.
Por lo tanto, estamos manejando la publicación get put y delete para
los comentarios de barra diagonal y los comentarios de barra diagonal barra diagonal impacto CommentID.
Entonces, una vez que
hayamos completado esto, entonces necesitamos incluirlo en el archivo app.js.
Por lo tanto, entraremos en el archivo app.js y luego diremos
var CommentRouter
requiere rutas/CommentRouter.
Entonces, tenemos el enrutador de comentarios aquí y luego
bajaremos al archivo app.js abajo aquí y
luego diremos app.use
slash comments, CommentRouter aquí.
Eso es todo. Así que ahora,
mi enrutador de comentarios está listo.
Entonces, sigamos adelante y guardemos todos los cambios.
Entonces nuestro servidor se actualiza
para manejar todas las solicitudes de nuestros clientes React aquí.
Ahora, si quieres hacer la forma alternativa, es decir,
tienes tus comentarios como sub-documentos de tu plato y luego quieres manejarlo,
entonces necesitarás actualizar el cliente React
para poder usar los comentarios desde dentro de cada plato apropiadamente.
Eso se dejará como un ejercicio para ti.
Piense en cómo diseñaría su cliente de reacción de tal manera que
funcione muy bien con la versión anterior
del servidor que tenía los comentarios como sub-documentos de sus propios platos.
Ahora, esa será una forma interesante de implementarlo.
Por supuesto, es un poco más complicado que la forma en que
implementamos el cliente React donde mantuvimos
los comentarios independientes de los platos, pero luego el trabajo adicional es responsabilidad
del lado del cliente porque necesitas seleccionar
los comentarios apropiados cuando estás mostrando un plato específico.
Debe seleccionar los comentarios de todos los comentarios aquí.
Por lo tanto, ese es un trabajo adicional que nuestro cliente React hace debido a
que separamos los comentarios de los propios platos.
Del mismo modo, si puedes rediseñar tu cliente angular para poder
lidiar con la situación en la que los comentarios se mantienen independientes de tus platos.
Ahora, estos son todos los ejercicios que puede hacer para ver cómo puede
extender sus aplicaciones cliente para manejar cualquier tipo de servidor,
los dos tipos diferentes de servidores allí.
Por lo tanto, con esto, completamos la actualización de nuestro servidor aquí.
Por lo tanto, con esto, hemos actualizado todo en el lado del servidor.
Por lo tanto, guardemos todos los cambios en el lado del servidor.
Así que ahora, nuestro servidor está listo para manejar las solicitudes entrantes de nuestro cliente React.
Con esto, completamos este ejercicio.
En este ejercicio, ahora hemos preparado nuestro servidor express
para manejar las solicitudes entrantes de nuestro cliente React.
En el próximo ejercicio, vamos a ver el cliente reaccionar con más detalle para
entender cómo se está comunicando con este servidor adicional.
Este es un buen momento para que haga
una cobertura git con el mensaje que integra cliente y servidor.