En el ejercicio anterior,
hemos visto lo fácil que fue para nosotros configurar y luego
andamiar un servidor de destinatarios usando el marco LoopBack.
Vemos que este marco de LoopBack soporta todo un espectro
de los endpoints destinatarios y
todas las operaciones de los endpoints destinatarios automáticamente para nosotros,
cuando desarrollamos nuestra aplicación.
En este ejercicio, veremos cómo podemos conectar
nuestro servidor LoopBack a una base de datos back-end,
o MongoDB en esta instancia,
y también veremos cómo podemos configurar varios controles de acceso en los extremos del destinatario.
Por lo tanto, utilizando los controles de acceso,
podemos especificar qué tipo de operaciones se pueden llevar a cabo en los puntos finales del destinatario,
y a quién se le permitirá llevar a cabo esas operaciones.
Entonces, por ejemplo, un usuario no autenticado o un invitado solo puede
acceder a la información o realizar una operación get en los extremos del destinatario,
un usuario autenticado también podría hacer lo mismo,
pero solo un administrador podría escribir datos en mi servidor.
Por lo tanto, cualquier operación de poner, publicar y eliminar solo puede ser llevada a cabo por un administrador. En
el camino también veremos cómo podemos configurar una cuenta de administrador en nuestro servidor LoopBack,
y luego configurarla para que
solo el usuario administrador pueda realizar estas operaciones.
Así que aquí es donde LoopBack nos permite definir algo
llamado roles asociados con varios usuarios.
Por lo tanto, a cada usuario se le puede asignar un rol.
Como ejemplo, puede hablar de un usuario común,
un administrador, un superadministrador, etc.
Por lo tanto, puede subdividir su conjunto de usuarios en varios grupos
y, a continuación, asignarles varios roles.
También veremos cómo el modelo de usuario incorporado se puede personalizar aún más,
dentro de nuestra aplicación LoopBack,
y cómo podemos construir otro modelo sobre el modelo de usuario,
y luego usar el modelo de usuario como la clase base
y desarrollar un modelo de nivel superior llamado Modelo de cliente,
que nos permite almacenar información adicional para cada uno
de los clientes que iniciarán sesión en nuestro sitio.
Por lo tanto, vamos a explorar algunas de estas características de LoopBack en este ejercicio.
Para empezar en este ejercicio,
lo primero que me gustaría que hicieras
es arrancar tu servidor MongoDB.
Así que aquí estoy en otra pestaña de terminal en mi carpeta MongoDB,
donde configuré mi servidor MongoDB anteriormente,
que fue utilizado por mi servidor Express Plus MongoDB en los ejercicios anteriores.
Así que permítanme iniciar el servidor MongoDB escribiendo
MonGod menos los datos de parte D-B
en esta carpeta y luego iniciar mi servidor MongoDB.
Ahora, voy a conectar mi servidor LoopBack a mi servidor MongoDB.
Así que al entrar en mi carpeta de servidor LoopBack aquí,
tengo que preguntar tipo fuente de datos L-B.
Esto nos permitirá configurar la fuente de datos para nuestro servidor LoopBack.
LoopBack puede conectarse simultáneamente a múltiples fuentes de datos si así lo decide,
y admite varios tipos.
Soporta bases de datos My Cycle, soporta MongoDB,
soporta Cloudant que también es otra base de datos de documentos,
soporta Oracle y muchos otros tipos de bases de datos.
Por lo tanto, puede configurar fácilmente eso.
En este ejemplo, voy a configurar mi servidor LoopBack
para hablar con mi MongoDB en el back-end.
Así que en el mensaje,
si escribimos fuente de datos L-B,
nos pedirá información.
Así que lo primero que nos pedirá es el nombre del origen de datos,
y luego configuraré este nombre de fuente de datos como MongoDB,
y luego me pedirá que seleccione el conector.
LoopBack utiliza conectores para conectarse a varias bases de datos entre bastidores.
Entonces, como puede ver, el DB en memoria que es el que
acaban de usar en el ejercicio anterior,
pero por supuesto, el DB en memoria significa que una vez que apague su servidor,
todos los valores desaparecerán,
y eso no es un almacenamiento de datos persistente.
Así que aquí puede ver los diversos tipos de bases de datos que StrongLoop soporta aquí.
Así que puede ver la larga lista de las diversas bases de datos que son compatibles.
Así que se puede ver que soporta Cassandra, Redis,
nos habíamos referido brevemente a estos cuando hablamos de bases de datos NoSQL, MongoDB,
My SQL, PostGres, Oracle,
e incluso directamente a otros servidores API Rest a servidores SOAP,
Coachbase y así sucesivamente.
Así que usted ve que nos proporciona
una larga lista de varios tipos de fuentes de datos desde allí,
nuestro servidor LoopBack puede leer en la información.
En mi caso, voy a usar el servidor MongoDB, así que
voy a configurar el conector MongoDB.
Entonces, cuando hago eso,
LoopBack instalará automáticamente el conector MongoDB para nosotros,
y cuando solicite la URL de la cadena de conexión,
dejaremos esto vacío
porque le permitiremos usar la forma estándar de configuración.
Cuando pregunte por el host diremos
localhost porque estamos ejecutando nuestro MongoDB en el mismo equipo.
De lo contrario, especificará
el nombre de host del equipo en el que se está ejecutando MongoDB.
Entonces el siguiente es el número de puerto y estamos
usando nuestro número de puerto estándar MongoDB 27017,
y también pedirá el nombre de usuario y la contraseña si es necesario,
y en este momento mi MongoDB se está ejecutando sin tener que
hacer ninguna autenticación, así que dejo el nombre de usuario y la contraseña vacíos,
y el nombre de base de datos.
El nombre de la base de datos en el servidor MongoDB que se ejecuta detrás de las escenas,
el nombre de la base de datos hay confusión.
Si recuerda que ese es el nombre de la base de datos que han configurado en nuestro servidor MongoDB.
Y luego nos preguntará si debe instalar el conector LoopBack,
y diré que sí, y en
realidad seguirá adelante e instalará el módulo NPM que accede al
conector LoopBack a la base de datos MongoDB.
Y una vez hecho esto,
mi conector Loopback está instalado aquí para que pueda ver que esta es la versión 1.18.1
y mi servidor LoopBack está listo para hablar con mi MongoDB.
Ahora, antes de continuar,
en el ejercicio anterior realmente no configuro algunos modelos
y luego los especifico para almacenarlos en el DB,
necesitaré ir y actualizarlos para almacenar sus datos en mi MongoDB.
Por lo tanto, vamos a restablecer rápidamente nuestro código para el servidor LoopBack.
Esto también nos brinda la oportunidad de ver
lo que mi servidor Loopback ha configurado en esta carpeta.
Al abrir la carpeta LoopBack en nuestro editor,
puede ver que Loopback ya tiene
un montón de archivos en esta carpeta.
El package.json, por supuesto, contiene
todos los módulos NPM relacionados que se han configurado aquí,
y aquí puede ver que LoopBack sí mismo ha configurado el módulo LoopBack NPM,
el módulo de arranque LoopBack y, en
particular, permítanme llamar su atención sobre el LoopBack MongoDB ,
que acabamos de instalar hace poco, y muchos otros.
En particular, la configuración para el servidor Loopback se
almacena principalmente en archivos Json aquí,
con javascriptcore adicional siempre que sea necesario.
Buscaremos la personalización del código javascript un poco más tarde.
Permítanme llamar su atención sobre esta carpeta llamada común.
En esta carpeta común,
verá todos los modelos que hemos configurado anteriormente.
Así que verá que tenemos los archivos dishes.json.
Entonces, cuando abre el archivo dishes.json, ve cómo LoopBack
almacena toda la información sobre el modelo de platos que acaba de crear,
por lo que tiene el nombre, la base
y algunos otros valores aquí que requiere.
Y luego mira las propiedades y cómo todas las propiedades se almacenan aquí.
Así que ves algunas cosas que son muy fáciles de
reconocer que están en el archivo dishes.json.
Del mismo modo, los leaders.json y los promotions.json.
El archivo dishes.js es grande,
podemos agregar algún código de personalización adicional para los platos,
pero en este momento no vamos a hacer eso,
por lo que simplemente lo dejaremos tal como está.
Entonces, aquí es donde puede agregar algún código adicional que puede
necesitar ejecutarse cuando accede al punto final de los platos de barra diagonal.
Pero ahora mismo vamos a dejarlo en blanco por el momento.
Ahora veamos también la carpeta del servidor aquí.
Y la carpeta del servidor,
en particular, permítanme llamar su atención sobre el archivo datasources.json aquí.
En el archivo.json de origen de datos,
todas las fuentes de datos diferentes se configurarán aquí.
Así que ahora mismo, solo tenemos el DB que es
la base de datos de base de datos en memoria que LoopBack configura por defecto,
y luego el MongoDB que acabamos de configurar,
solo absorbió la información de que la entrada
se ha almacenado en esas fuentes de datos, archivo json.
Por lo tanto, verá que LoopBack funciona configurando todos estos archivos
que el marco de LoopBack hace uso cuando
inicia el servidor de API de descanso basado en Loopback.
Vamos al archivo config.json modelo aquí.
El archivo config.json del modelo
almacena una gran cantidad de información aquí que es útil para nosotros,
pero aquí, vamos a entrar y modificar algunas cosas.
Así que en esto, veremos que hay de nuevo para los platos,
promociones y líderes, la fuente de datos se ha configurado como DB.
Así que vamos a modificar eso a MongoDB aquí.
No solo para este,
también cambiarán eso para promociones, y también líderes,
lo que significa, que todos estos tres derivarán sus datos del MongoDB.
Además, para el Rol que se define aquí.
También almacenaremos en MongoDB.
Muy pronto veremos cómo vamos a hacer uso del rol,
y también del rolemapping aquí.
Entenderemos la razón de estos dos en poco tiempo.
Y luego, ACL, las Listas de Control de Acceso,
estas también se almacenarán en MongoDB.
Y luego, el usuario, también,
lo almacenaremos en MongoDB,
y luego lo dejarán allí.
Por lo tanto, estas son las modificaciones que debe hacer en
el archivo model-config.json y luego guardar los cambios.
Como mencioné anteriormente, Loopback de forma predeterminada,
soporta este modelo llamado, usuario,
que se utiliza para admitir la autenticación del usuario.
El propio modelo de usuario almacena solo tres propiedades diferentes.
El nombre de usuario, la dirección de correo electrónico
y la información relacionada con la contraseña.
Ahora, si quieren tener
una forma más elaborada de almacenar información adicional sobre los usuarios.
Luego pueden subclasificar este modelo base de usuarios,
y luego hacer uso de eso.
Entonces, en este próximo paso,
voy a crear otro modelo llamado, el modelo del cliente,
que utilizará al usuario como modelo base para su funcionamiento.
Y el modelo de cliente en sí almacenará información adicional sobre los usuarios.
Entonces, en el modelo del cliente,
almacenaré las cosas como
el nombre, el apellido y la imagen para el usuario, etc.
Por lo tanto, el cliente actuará exactamente como el modelo de usuario,
que ya viene con su propio conjunto de métodos.
Por lo tanto, el modelo de usuario se utiliza para la autenticación del usuario, de
modo que puede escribir el nombre de usuario y la contraseña,
e iniciar sesión y cerrar sesión.
Por lo tanto, cuando creamos este modelo de cliente basado en la clase base del modelo de usuario,
el modelo de cliente también admitirá
las operaciones de inicio de sesión y cierre de sesión en el uso de este modelo de cliente.
Por lo tanto, podemos iniciar sesión en el usuario y cerrar la sesión del usuario y así sucesivamente.
Por lo tanto, la autenticación del usuario viene automáticamente por la derecha.
Por lo tanto, para crear el modelo de cliente, en el mensaje,
escriba lb model y para el nombre del modelo,
escribiremos Cliente.
Y el DataSource, lo elegiré como MongoDB.
Y luego, cuando solicite seleccionar la clase base del modelo,
en lugar de usar PersistedModel
, bajaremos
y luego seleccionaremos el Usuario como clase base.
Por lo tanto, de esa manera, derivará todas sus propiedades
de la clase de usuario base que ya está integrada en Loopback.
Y luego expondremos esto con la API REST
y el MT plural personalizado.
Y entonces esto estaría en la carpeta común.
Y para esto, las tres propiedades que vamos a agregar son,
nombre, que tendríamos la cadena de tipos.
Y esto no es obligatorio o no tiene un valor predeterminado.
Y, a continuación, el apellido de nuevo como la cadena de tipo,
no es necesario, y ningún valor predeterminado.
Y luego la imagen de la cadena de tipo,
no es necesaria y no hay valor predeterminado.
Por lo tanto, verá que la clase de cliente
tiene propiedades adicionales además de la clase de usuario.
la clase de usuario ya admite el nombre de usuario,
el correo electrónico y la información relacionada con la contraseña.
Por lo tanto, la clase de cliente,
ya que la subclase es la clase base,
obtendremos el nombre de usuario y el correo electrónico automáticamente de la clase de usuario.
Y ahora, cuando vaya al archivo model-config.jason,
verá que el modelo de cliente ya se ha agregado allí.
Y luego, en los modelos comunes,
ahora verá el archivo customer.json agregado allí
con estas tres propiedades adicionales que hemos agregado al modelo de cliente.
Pero tenga en cuenta que especifica la base como la clase de usuario para el modelo de cliente aquí.
Entonces, así es como Loopback le permite tomar
una clase de modelo base y luego subclase eso en la clase modelo.
Por lo tanto, verá cómo Loopback nos permite admitir automáticamente la autenticación de usuario usando
la clase de usuario y luego nos permite incluso definir subclase adicional de esa,
que almacenará información adicional relacionada con la clase base de usuarios.
A continuación, configuraremos el Control de Acceso para
los diferentes modelos que ya hemos configurado en nuestro servidor Loopback.
Por lo tanto, para configurar el Control de Acceso,
o las Listas de Control de Acceso en Lookback.
Loopback utiliza estas listas de control de acceso como una forma de especificar qué tipo de
operaciones se pueden realizar en
los diferentes extremos de la API REST se corresponden con los diferentes modelos.
Por lo tanto, para hacer eso, escribiremos en el indicador lb acl,
ACL significa listas de control de acceso.
Y luego, cuando esto se agote, diremos, a
qué modelo queremos que se aplique esta lista de control de acceso.
Y luego diremos, todos los modelos existentes.
Y diremos, Todas las métricas y propiedades.
Y diremos,
Todo tipo de operaciones.
Y luego, diremos, Todos los usuarios.
Y luego diremos: Denegar explícitamente el acceso.
Por lo tanto, primero estamos cerrando todos los modelos para todo,
luego nos abriremos lentamente,
independientemente de las operaciones que puedan realizar diferentes usuarios.
Por lo tanto, primer paso, hemos cerrado
todos los tipos de operaciones en todos los modelos que tenemos actualmente.
Luego, lentamente comenzaremos a abrir todas y cada una de las operaciones, paso a paso.
Ahora, el siguiente paso,
lo que vamos a hacer es volver a configurar la siguiente lista de control de acceso.
En la segunda lista de control de acceso, diremos,
para todos los modelos existentes y diremos,
Todas las métricas y propiedades.
Y luego, diremos, solo acceso de lectura.
Es decir, cuando el usuario puede realizar las operaciones GET en estos puertos finales.
Y estas operaciones GET pueden ser realizadas por todos los usuarios.
Por lo tanto, los usuarios pueden recuperar información.
Y concederemos explícitamente el acceso para esto.
Por lo tanto, lo que significa que las operaciones GET están permitidas en el nodo de extremos de la API REST.
Primero, cerramos todo,
luego abrimos solo las operaciones GET para los usuarios.
Ahora, finalmente, irán a cada uno de los modelos,
y luego se cerrarán y permitirán que ciertas operaciones solo
sean realizadas por ciertos tipos de usuarios.
Por lo tanto, para hacer eso,
la próxima ACL que vamos a configurar es para un modelo específico.
Así que prepararemos este para los platos.
Y diremos, un solo método.
Y luego el nombre del método es, crear.
Por lo tanto, lo que significa que la creación de estos sólo será permitida por.
Por lo tanto, de nuevo, cuando se dice seleccionar el rol,
entonces para el rol, vamos a decir, otro.
Y luego el nombre del rol sería admin. Por
lo tanto, lo que estamos haciendo con esta operación es que,
estamos diciendo que solo un usuario administrador puede crear nuevos platos o actualizar los platos existentes.
Por lo tanto, esto es un poco cerca, las operaciones restantes.
Por lo tanto, hagamos lo mismo por los líderes.
Y un solo método y luego,
el crear y diremos,
solo el administrador puede hacer esto.
Y luego, finalmente, también para promociones.
Para promociones.
El método único, el método de creación
sólo será permitido por los usuarios que tengan el rol designado como administrador.
Veremos cómo vamos a crear usuarios con un rol específico en el siguiente paso.
Conceder acceso explícitamente.
Ahora observe que no he cerrado clientes para crear operaciones.
Si cierro clientes,
nadie podrá registrarse en el sistema.
Así que, por eso dejaré eso abierto.
Porque, el cliente debe poder registrarse en el sistema.
Por lo tanto, puede registrarse para nuevas cuentas en el sistema.
Cuentas de usuario en el sistema.
Por lo tanto, eso quedará abierto para que la gente lo haga.
Por lo tanto, para permitir que para los clientes, vamos a decir, clientes,
Un método único, crear todos los usuarios.
Por lo tanto, los clientes pueden ser creados por todos los usuarios porque eso
permitirá a las personas iniciar sesión en su cuenta.
Finalmente, veremos cómo podemos configurar nuestro servidor para que se inicie
con un único usuario administrador configurado automáticamente en nuestro servidor Loopback.
Por lo tanto, para hacer eso,
en nuestro servidor Loopback,
en la carpeta del servidor tenemos esta subcarpeta de arranque aquí.
Cualquier código que coloquemos en la subcarpeta de arranque,
se ejecutará en el inicio de nuestro servidor LoopBack.
Entonces, aquí, verá que ya tenemos este authentication.js,
que ya está configurado,
un Loopback que configurará la autenticación de usuario para nosotros.
Y luego tenemos el root.js que configurará
alguna información adicional para nuestro servidor RAM Loopback.
Y podemos añadir archivos adicionales aquí.
Entonces, voy a entrar allí en la carpeta de arranque,
y luego agregar este archivo llamado, script.js.
Y en este script.js,
voy a configurar el código para crear un usuario administrador de forma predeterminada.
Entonces, en el script.js,
que no será más que un módulo NPM basado en archivos, entonces,
comenzaremos diciendo,
module.exports = function (app).
La aplicación es la aplicación Loopback,
que se suministrará como parámetro a esta función para nosotros.
Por lo tanto, podemos hacer uso de él dentro de nuestro código aquí.
Por lo tanto, aquí, primero configuraremos un usuario administrador.
Por lo tanto, para hacer eso, diremos,
var Cliente = app.models.Customer.
Por lo tanto, esto nos da acceso al modelo de cliente.
Entonces diremos, clientes.findone.
Por lo tanto, primero comprobaremos si un usuario con
el nombre de usuario como admin ya está configurado en el sistema o no.
Si no, entonces voy a crear un usuario administrador.
Y esto me proporciona una función de devolución de llamada con dos parámetros, err y usuarios.
Y dentro de esto- Así que primero intentaremos
ver si ya existe un usuario con su nombre admin.
Si el usuario no existe,
entonces crearemos el usuario.
Entonces, para crear el usuario,
diremos aquí, si no los usuarios.
Entonces, si los usuarios no son nulos o si el usuario dice nulo,
entonces eso significa que no hay usuario administrador, así que necesito crear un usuario administrador aquí.
Entonces, en este caso, diremos, customer.create.
Y esta creación toma una matriz de objetos si lo desea.
Y esta matriz de objetos nos permitirá especificar qué cuentas de usuario queremos crear.
Entonces, la primera cuenta de usuario que quiero crear o
la única cuenta de usuario que quiero crear es la 'Administrador'.
Así que este será el administrador predeterminado para
mi servidor de bucle invertido y luego puedo configurar el correo electrónico.
Así que recuerde que el modelo de usuario admite estas propiedades,
confusion.net y luego la contraseña
que configuraré como contraseña.
También puede proporcionar junto con esto,
el nombre y el apellido,
si lo desea, para el usuario administrador.
Pero voy a dejarlo como tal,
como vacío porque no son necesarios para el usuario administrador.
Así que voy a dejarlo ahí.
Así que este comando terminará creando un nuevo cliente con el nombre 'Admin'.
Así que si este usuario o el nombre «Admin» no existe,
entonces vamos a crear uno.
Y luego aquí tenemos la función de devolución de llamada.
Así que erran usuarios.
Ahora voy a decir,
si erran, no sabemos lo que está tratando de hacer así que simplemente lanzaremos el error.
Pero normalmente no esperaremos que esto suceda.
Entonces, ¿cómo designa a este usuario como usuario administrativo?
Así que ahora mismo, cuando me inscribo aquí,
solo estoy registrando a un usuario normal aquí,
pero queremos darle un rol especial a este usuario.
Entonces, ahí es donde el bucle invertido admite una forma de especificar roles para los usuarios.
Entonces, para especificar un rol,
vamos a var Role = App.Models.Role.
Así que esto me permitirá crear un rol,
un nuevo administrador de llamada de rol aquí.
Así que podemos asignar diferentes drones a diferentes usuarios si lo desea.
Y junto con esto,
también necesito crear un RoleMapapping aquí.
Así que diremos, App.Models.Rolemapping.
Y si sucede que la base de datos ya contiene
cualquier RoleMapping que ya existe,
entonces voy a destruir todos esos cuando inicie mi servidor.
Y luego déjame
intentar ver si
ya
existe un rol con ese nombre admin en el sistema.
Está bien.
Y en esto toma,
como era de esperar,
una función de devolución de llamada y dentro de aquí diremos, Role. Findone.
Entonces, si ya existe un rol con el nombre admin,
entonces no necesito crear uno.
De lo contrario, si eso no existe,
entonces necesito crear el rol.
Así que diremos, Rol. Create.
Así que vamos a crear el rol de administrador aquí.
Y luego esto nos lleva a los parámetros err,
rol aquí, en la función de devolución de llamada.
Ahora de nuevo, aquí para manejar el error,
simplemente copiaremos este 'if err' y luego lo pegaremos allí.
Del mismo modo aquí también, si ocurre el error,
entonces necesito manejar eso.
Así que 'si errar' entonces 'arroja el error'.
De lo contrario, hemos creado el rol.
Así que ahora necesito asignar este rol a este usuario en particular que acabo de crear.
Este usuario que acabo de crear aquí.
Este usuario. Quiero darle a este usuario ese rol del administrador.
Así que ya que he creado este rol por el nombre admin,
así que diremos, role.principals.create.
Así es como se crea una asignación entre el rol y un usuario en particular aquí.
Así que diremos, role.principals.create.
Así que esta es la sintaxis allí.
Diremos, principalType: rolemapping.user
aquí y tomará
una identificación principal aquí, que son los usuarios.
Ahora, ¿a qué se refiere este usuario?
Estos usuarios se refieren a esto que acaba de entrar.
Así que cuando creamos estos usuarios,
entonces el cliente debe crear un retorno exitoso a nosotros aquí.
Así que eso es lo que voy a usar aquí.
Vamos a decir, usuarios [0].
Por lo tanto, esta sería una matriz de usuarios que se han creado y contienen solo uno de ellos.
Entonces, es por eso que estoy diciendo usuario [0].
Y luego asignaremos el ID de ese usuario aquí.
Así es como crearemos un RoleMapping entre el rol que acabamos de crear,
este rol, y luego lo asignaremos al cliente que acabamos de crear.
Ahora esto también nos lleva a los parámetros, la función de devolución de llamada.
Y en esta función de devolución de llamada simplemente diremos,
if (err) throw (err).
De lo contrario, no estamos realmente interesados en saber qué más ha sucedido allí.
Eso es todo. Así que así es como.
Por lo tanto, si el rol denominado admin no existe,
crearemos ese rol.
Si no - Así que esta es la
parte 'otra' donde todavía tendré que hacer este mapeo.
Así que déjame copiar ese código y luego haré exactamente eso aquí.
Entonces role.principals.create y luego mapea esto para el usuario allí.
Entonces, si el rol de administrador ya existe,
entonces todo lo que necesitan hacer es hacer la asignación.
Así que esto se almacenará en el modelo RoleMapping en nuestra base de datos. Eso es todo.
Así que este fragmento de código que ponemos en el archivo script.js primero intentará
encontrar si existe un usuario administrador y ese usuario es identificado por el nombre admin.
Si no es así, se creará el usuario y también creará el rol para el usuario.
Vamos a crear un rol llamado admin.
Si ese rol existe,
entonces lo usaremos.
De lo contrario, crearemos el rol.
Y luego, después de eso, crearemos este mapeo entre el rol y el usuario.
Por lo tanto, el loopback nos permite hacer el RoleMapping.
Así que decir que este usuario no es para este rol.
Por lo tanto, este mapeo se realiza mediante el uso de esta declaración.
Así que esto completa la configuración de nuestros servidores.
De modo que se creará un usuario administrador y ese usuario administrador
obtendrá automáticamente el rol del administrador tal y como está configurado aquí.
Eso es todo. Vamos a guardar los cambios en script.js.
Y ahora nuestros servidores de bucle invertido deberían estar listos.
Así que ahora iremos y comenzaremos nuestro servidor de retroceso y luego comprobaremos qué podemos hacer con esto.
Ir a los terminales,
vamos a iniciar el servidor de bucle invertido.
Así que diremos, npm start y entonces nuestro servidor debería estar en funcionamiento.
Vamos al Explorador y luego naveguemos la información allí.
Y este servidor de bucle invertido se
conectará automáticamente a mi MongoDP porque he configurado la conexión.
Al ir a mi navegador,
déjame volver a cargar esto.
Y cuando vuelva a cargar
esto, verá que tenemos un nuevo cliente que se ha creado aquí.
El usuario ya existía anteriormente.
Los platos, líderes y promociones están todos ahí.
Vamos a realizar un get en los platos.
Ahora que esto está conectado a la boca MongoDB,
mi MongoDB ya tiene algunos platos allí.
Si su MongoDB está vacío,
puede publicar algunos platos usando el post aquí.
Así que vamos a probarlo.
Cuando hago una operación de conseguir en los platos de corte,
verás que en el cuerpo de respuesta -
Todos los platos que existen en mi base de datos han sido recuperados.
Del mismo modo, puedo hacer un GET en
promociones y debería ver la promoción que ya existe en mi base de datos allí.
Por lo tanto, puede ver que la promoción ya existe allí.
Por lo tanto, eso nos muestra cómo podemos obtener información.
Ahora, tratemos de publicar un nuevo plato.
Entonces, para publicar un nuevo plato,
vamos a la POST aquí.
Déjame copiar esto.
Obviamente, en este momento,
porque ya que no estoy conectado,
no se me permitirá publicar el plato así,
pero voy a demostrar que a usted son sólo copiar y pegar esta información aquí,
y vamos a tratar de publicar ese plato,
y luego cuando trato de publicar el plato,
mi servidor responde inmediatamente con este error diciendo, AUTHORIZATION_REQUERED.
No está autorizado a realizar esta operación.
Entonces, es por eso que no está autorizado a hacer esta operación.
Ahora, ¿cómo se autoriza a sí mismo?
Por lo tanto, para autorizarse,
ahora recuerde que ya hemos creado un usuario con el nombre admin,
y este usuario administrador ya existe como cliente aquí.
Por lo tanto, al entrar en los extremos de la API REST del cliente,
si se desplaza
hacia abajo, abajo aquí abajo, verá el inicio de sesión de este cliente.
Por lo tanto, cuando haces un POST en el inicio de sesión del cliente.
Por lo tanto, para el inicio de sesión del cliente,
desplácese hasta aquí y luego aquí pide las credenciales.
Entonces, en las credenciales,
podemos escribir el nombre de usuario entre comillas dobles, y diremos
, Administrador, y luego contraseña,
diremos, contraseña, y luego publicaremos esto.
Y luego, cuando lo
publique, notará que en la respuesta,
LoopBack me enviará esta información.
Ahora, dentro de esta información,
esta identificación particular que envía de vuelta es el AccessToken para mi servidor LoopBack.
Entonces, puedo copiar este AccessToken aquí,
y luego justo en la parte superior aquí,
puedes ver que esto es Token Not Set, aquí.
Dice Token Not Set.
Y aquí puede escribir este AccessToken,
y luego decir, Establecer token de acceso.
Y luego se establecerá su AccessToken,
y luego todas las operaciones posteriores que realice llevarán automáticamente
este AccessToken en el encabezado de mi mensaje de solicitud.
Entonces, de esa manera, ahora mi administrador podrá hacer publicaciones de elementos allí.
Así que, ahora que he iniciado sesión como administrador,
déjame ir a promociones,
y luego publicaré una promoción allí,
y te mostraré que puedo publicar promociones.
Por lo tanto, vamos a un POST,
y luego simplemente copiaremos esto, y luego en los datos,
y luego para el nombre diremos, Promoción de prueba
e imagen simplemente lo dejaremos como tal, descripción, descripción de prueba.
Y puedo publicarlo allí,
y verá
que no debería incluir esta identificación aquí porque he
dejado que LoopBack le asigne automáticamente la identificación.
Permítanme publicar esto y luego vería que en el cuerpo de respuesta,
la promoción de la prueba se ha publicado aquí.
Y acabo de notar que no he incluido
la bandera destacada para mis promociones y mis líderes.
Por lo tanto, voy a entrar e incluir la bandera destacada como
una de las partes de mis promociones allí.
Así que, ahora cuando haga un GET para las promociones,
verá que en ese mensaje de respuesta,
verá la promoción anterior que ya estaba en mi base de datos
y luego la nueva promoción que acabo de publicar en mi base de datos ya incluida aquí.
Por lo tanto, acabo de notar que necesito establecer el indicador destacado,
le mostraré cómo hacerlo en una.
por lo tanto, ese tipo de demuestra a usted cómo puede iniciar sesión y explorar su servidor LoopBack.
Permítanme destruir este token,
así que simplemente eliminaremos el token,
y luego
haremos clic en eso para que esencialmente envíe el token de acceso a una
cadena vacía y así mi token ya no se procesará,
por lo que ahora mi usuario ya no está conectado.
Permítanme crear un nuevo cliente.
Por lo tanto, para crear un nuevo cliente voy a decir, clientes POST.
Y luego copiaré esto desde aquí.
Voy a crear una nueva cuenta aquí.
Y así, aquí,
eliminaré el reino,
no necesito eso, no necesito la identificación.
Por lo tanto, para el nombre
y el EmailVerified deben ser configurados automáticamente por el sistema.
Por lo tanto, permítanme iniciar sesión como este usuario.
Por lo tanto, solo voy a enviar mi nombre, apellido
y la imagen actualmente,
simplemente estableceré una cadena vacía allí, nombre de usuario y correo electrónico.
Y luego lo probaremos,
y luego vuelve diciendo
: Detalles: 'contraseña' no puede estar en blanco.
Por lo tanto, se dará cuenta de que aquí,
también debería incluir junto con el nombre de usuario,
contraseña y luego, vamos a publicar esto.
Por lo tanto, cuando lo publiques, vuelve con
el Cuerpo de Respuesta diciendo que ahora eres parte del sistema.
Por lo tanto, su nombre,
su apellido y su nombre de usuario, su ID de correo electrónico
y el ID que LoopBack le asigna se le devuelve.
Entonces, esto no es más que la identificación de MongoDB como puede ver aquí.
Por lo tanto, ahora que me
he registrado como cliente, debería poder iniciar sesión como cliente,
para ir al inicio de sesión POST aquí,
y luego aquí en lugar del administrador,
voy a iniciar sesión como el nuevo usuario que he iniciado sesión.
Entonces, luego hago clic en Probar,
verás que regresa con el id,
por lo que me da el token para este usuario administrador aquí.
Por lo tanto, con esto hemos completado el examen del servidor LoopBack que acabamos de crear.
Y como acabo de mencionar,
me di cuenta de que las promociones y los líderes no tienen bandera destacada, así que,
voy a entrar en el código.
Entonces, supongamos que olvidas algo como esto,
entonces simplemente puedes entrar y editar el código Json si lo deseas.
Entonces, voy a entrar en mi código,
ir al código,
primero voy a entrar en Commons y luego voy a ir a los dishes.json.
Y luego en los dishes.json,
veo esta propiedad destacada allí.
Voy a copiar esta propiedad destacada,
y luego iré a leaders.json,
y luego pegaré esa propiedad de característica en un leaders.json,
y también con promotions.json.
Olvidé incluir esto cuando creé esos modelos.
Debería haber hecho esto cuando estaba creando el modelo en sí, así que,
si olvidas algo como eso,
entonces esta es otra forma de editar tu modelo
y luego asegurarte de que tu modelo esté configurado correctamente.
Así que, eso es todo.
Por lo tanto, ahora mis promociones y líderes también tendrán la bandera destacada establecida allí.
Con esto, completamos este ejercicio.
En este ejercicio, hemos visto cómo podemos configurar
un nuevo modelo ampliando una clase de modelo base que ya está en LoopBack.
También vimos cómo podíamos configurar controles de acceso usando
las listas de control de acceso compatibles con LoopBack.
Con esto, completamos este ejercicio.
Este es un buen momento para que usted haga un cubrirse con
las fuentes de datos LoopBack mensaje y control de acceso.