Share
Sails.js es un marco prometedor de Node.js, centrado en la libertad y los valores predeterminados inteligentes. En este artículo, veremos algunas de las características de datos que Sails proporciona listas para usar, para crear aplicaciones complejas fácilmente..
La razón para elegir Sails es la mejor puesta por el creador de Sails, Mike McNeil, "Sails fue creado por necesidad". Muchos marcos que se ven alrededor, están construidos casi para el lado académico, estos marcos generalmente fomentan las mejores prácticas y crean una plataforma para que los desarrolladores creen cosas más rápido o mejor.
Por otro lado, Sails se creó para la producción, no trata de alimentar una nueva sintaxis o plataforma, es una base sólida, diseñada para crear "trabajo de cliente" con velocidad. El contraste puede ser sutil, pero hay algunas diferencias distintas.
Para ilustrar a qué me refiero, echemos un vistazo a Meteor. Meteor es probablemente la plataforma JS líder en la actualidad, pero es un excelente ejemplo de un marco, por el bien de un marco. Ahora, esto no es algo malo, soy un gran partidario de Meteor, lo que quiero decir es que se propusieron construir un marco e hicieron un buen trabajo, Mike por otro lado se propuso hacer que el trabajo del cliente sea más rápido . Navegar es solo un medio para llegar a un fin..
En Meteor, casi todo está abstraído y usas JavaScript más la API de Meteor para codificar todo. Considerando que Sails no pretende ser una nueva plataforma, por lo que nada está oculto.
Se basa en Socket.io y el popular framework Express, y usted tiene acceso a ellos en su totalidad, de forma nativa. ¿Estás empezando a ver la diferencia??
Además, dado que Sails está orientado a la producción en primer lugar, está construido con múltiples opciones de escalado y seguridad.
Hay mucho de lo que hablar, pero en este artículo me gustaría centrarme en cómo Sails maneja los datos y cómo puede aprovechar algunas de las funciones más avanzadas de Sails para realizar algunas acciones realmente interesantes..
En caso de que aún no tenga Sail intalled, puede hacerlo a través de NPM ejecutando:
sudo npm install -g velas
Ahora hablemos un poco sobre Socket.io y Express antes de entrar en Sails. Hay una buena serie premium en Express by Andrew Burgess si está interesado, pero aquí repasaré los conceptos básicos relevantes de estas dos bibliotecas:
Socket.io es una biblioteca de pub / sub, que se ejecuta tanto en el servidor como en el cliente, y les permite hablar a través de sockets web.
Un breve ejemplo podría ser algo como esto:
Accentsconagua
// Código para el servidor var io = require ("socket.io"); io.sockets.on ("conexión", función (calcetín) sock.emit ("welcomeMessage", hola: "world"); io.listen (80); Este código comienza requiriendo la socket.io biblioteca, escuchando una conexión, y luego cuando otro socket se conecta, le enviará un mensaje, dirigido a la mensaje de bienvenida Evento, y finalmente pasando algo de JSON..
A continuación, en el cliente escribirías algo como:
// Código para el cliente var sock = io.connect ('http: // localhost'); sock.on ('welcomeMessage', function (json) // Manejar evento recibido); Aquí nos conectamos al servidor y lo escuchamos. mensaje de bienvenida evento que acabamos de crear. Como puede ver, es un servidor de publicación / suscripción bastante simple, que es bidireccional (el cliente también podría emitir mensajes para el servidor).
Ahora echemos un vistazo a Express:
La forma más simple de una ruta Express podría ser algo como:
app.get ('/ users', function (req, res) res.send ("Hello from '/ users'!");); Esto define una ruta simple, de modo que cuando un usuario va a la dirección de su sitio e intenta acceder a la / usuarios Página, se les presentará el mensaje. "Hola de '/ users'!".
So Express es un marco para gestionar solicitudes HTTP y Socket.io es una biblioteca de comunicaciones websocket. Sin embargo, lo que el equipo de Sails ha hecho es mapear todas las rutas Express a Socket.io internamente. Lo que esto significa es que puede llamar a cualquiera de las rutas HTTP a través de sockets web.
¡Eso está muy bien! Pero, todavía falta una pieza del rompecabezas y esa es la Sails Blueprints.
Sails le permite generar modelos al igual que en otros marcos, la diferencia es que Sails también puede generar una API RESTfull lista para producción para ir con ellos. Esto significa que si generas un modelo llamado 'usuarios'puede ejecutar inmediatamente consultas RESTfull en el'/ usuarios'recurso sin ningún tipo de codificación necesaria.
Si es nuevo en las API REST, es solo una forma de acceder a los datos, donde las operaciones de CRUD se asignan a varios métodos HTTP.
Entonces un OBTENER solicitud de '/ usuarios'obtendrá todos los usuarios, un ENVIAR La solicitud creará un nuevo usuario, etc..
Entonces, Qué significa todo esto?
Significa que tenemos una API RESTfull completa, asignada a Socket.io a través de Sails, sin escribir una sola línea de código!
Pero, ¿por qué los sockets son mejores para recuperar datos que una solicitud de Ajax? Bueno, además de ser un protocolo más ágil, los sockets permanecen abiertos para la comunicación bidireccional, y Sails ha aprovechado esto. Sails no solo le pasará los datos, sino que lo suscribirá automáticamente a las actualizaciones de esa base de datos, y cada vez que se agregue, elimine o actualice algo, su cliente recibirá una notificación a través del socket web, que le informará al respecto..
Por eso Sails es tan impresionante.!
El siguiente tema que me gustaría cubrir es la integración de Backbone, porque si no está utilizando un marco de JavaScript, lo está haciendo mal..
Con esto en mente, Sails y Backbone son el par perfecto. La red troncal, como Sails, es extremadamente discreta, todas sus funciones están disponibles, se pueden anular y son opcionales..
Si ha usado Backbone antes de entonces, es posible que sepa que se conecta de forma nativa con las API REST, por lo que puede sincronizar los datos en el front-end con su aplicación Sails.
Pero ya basta de hablar, echemos un vistazo a todo esto en acción creando una aplicación de chat básica. Para empezar, abre una ventana de terminal y escribe:
navega nuevo ChatApp cd ChatApp navega genera usuarios modelo navega genera mensajes modelo navega genera mensajes controlador genera velas controlador principal
Esto creará una nueva aplicación y generará algunos archivos para nosotros. Puedes ver desde arriba, hay dos recursos diferentes que puedes generar; Modelos y controladores. Si está familiarizado con el patrón de diseño MVC, debe saber cuáles son, pero en resumen, los modelos son sus datos y los controladores tienen su código lógico. Así que vamos a necesitar dos colecciones, una para los usuarios y otra para los mensajes..
A continuación, para los controladores, necesitamos uno para manejar las rutas de la página, lo llamé 'principal', entonces tenemos un segundo controlador llamado'mensajes'. Ahora puede que se pregunte por qué creé un controlador con el mismo nombre que nuestro mensajes ¿modelo? Bueno, si lo recuerdas, dije que Sails puede crear una API REST para ti. Lo que sucede es que, al crear un controlador en blanco con el mismo nombre que un modelo, Sails sabrá retroceder y construir una API REST para el recurso correspondiente.
Entonces, hemos creado un controlador para nuestro mensajes modelo, pero no hay necesidad de crear uno para el modelo de usuarios, así que simplemente lo dejé fuera. Y eso es todo lo que hay para crear modelos y controladores..
A continuación, vamos a configurar algunas rutas..
Las rutas siempre son un lugar seguro para comenzar, ya que generalmente tiene una buena idea de qué páginas se van a hacer..
Así que abre el rutas.js archivo que está en el configuración carpeta, puede parecer un poco abrumador al principio, pero si elimina todos los comentarios y los agrega en las siguientes rutas, se quedará con algo como esto:
module.exports.routes = '/': controller: 'main', action: 'index', '/ signup': controller: 'main', action: 'signup', '/ login': controller: 'main', action: 'login', '/ chat': controller: 'main', action: 'chat';
Tenemos una página de inicio, una página de chat y luego dos páginas para manejar tanto las páginas de inicio de sesión como las de registro. Los puse todos en el mismo controlador, pero en Sails, puedes crear tantos controladores como quieras.
A continuación, echemos un vistazo a los generados. mensajes modelo que se puede ubicar en "api> modelos> Messages.js". Necesitamos agregar las columnas necesarias a nuestro modelo. Ahora esto no es absolutamente necesario, pero creará algunas funciones de ayuda para nosotros que podemos usar:
// Modelo de mensajes module.exports = atributos: userId: 'INT', nombre de usuario: 'STRING', mensaje: 'STRING';
Para el mensajes modelo, comenzamos con el carné de identidad del usuario al que pertenece este mensaje, un nombre de usuario por lo que no tendremos que consultar esto por separado, y luego lo real mensaje.
Ahora vamos a completar el modelo del usuario:
// Modelo de usuarios. Módulo.exportaciones = atributos: nombre de usuario: 'STRING', contraseña: 'STRING';
Y eso es todo, tenemos el nombre de usuario y contraseña atributos El siguiente paso es crear nuestras funciones de ruta dentro de la Controlador principal.
Así que abre el Controlador principal, que se puede encontrar en "api> controladores> MainController.js". Comencemos por crear una función para cada una de las rutas que definimos anteriormente:
var MainController = index: function (req, res) , signup: function (req, res) , login: function (req, res) , chat: function (req, res) ; module.exports = MainController;
Si está familiarizado con Express, le complacerá ver que estas funciones son funciones de ruta Express estándar. Reciben dos variables, req para la solicitud HTTP y res para crear la respuesta.
Siguiendo el patrón MVC, Sails ofrece una función para renderizar vistas. La página de inicio no necesita nada especial, por lo que solo vamos a renderizar la vista.
index: function (req, res) res.view (); ,
Sails se inclina más hacia la convención sobre la configuración, así que cuando llamas res.view (); Sails buscará un archivo de vista (con un .ejs extensión por defecto) usando el siguiente patrón: 'vistas> controllerName> methodName.ejs'. Así que para esta llamada, buscará 'vistas> principal> index.ejs'. También vale la pena señalar que estas vistas solo contienen las partes específicas de la página. Si echas un vistazo avistas> layout.ejs', verás una llamada en el medio para <%- body %>, aquí es donde se insertará el archivo de vista. Por defecto usa este 'layout.ejs'archivo, pero puede usar otros archivos de diseño simplemente pasando el nombre del diseño a la res.view () Función, bajo la propiedad denominada 'layout'. Por ejemplo: 'res.view (layout: "other.ejs");'.
Voy a usar el archivo de diseño predeterminado con un pequeño ajuste, voy a agregar jQuery, Backbone y Underscore. Así que en el 'layout.ejs'archivo justo antes del cierre etiqueta, agregue las siguientes líneas:
Con eso en su lugar, ahora estamos listos para crear la página de inicio.
Vamos a crear una nueva carpeta dentro de la puntos de vista carpeta llamada principal, y dentro de nuestro nuevo principal carpeta, crearemos un nuevo archivo llamado 'index.ejs'.
Dentro del archivo, creamos un formulario de inicio de sesión y registro:
Código de chat
Iniciar sesión
Regístrate
Bastante simple, solo lo esencial..
A continuación, debemos agregar un poco de JS para que esto se comunique con el servidor. Ahora esto no será específico de Sails, solo enviaremos una solicitud AJAX a través de jQuery al servidor de Sails.
Este código puede incluirse en la página o cargarse a través de un archivo JS separado. Para mayor comodidad, solo lo pondré en la parte inferior de la misma página:
Todo esto es solo el estándar JS y jQuery, estamos escuchando el evento de clic en el botón de inicio de sesión, asegurándonos de que los campos de nombre de usuario y contraseña estén completos, y publicando los datos en el '/iniciar sesiónruta Si el inicio de sesión es exitoso, redirigimos al usuario a la página de chat, de lo contrario, mostraremos el error devuelto por el servidor.
A continuación, vamos a crear lo mismo para el área de registro:
$ ("# signupButton"). click (function () var username = $ ("# signupName"). val (); var password = $ ("# signupPassword"). val (); var confirmPassword = $ (" #signupConfirmPassword "). val (); if (username && password) si (password === confirmPassword) $ .post ('/ signup', username: username, password: password, function () window. location = "/ chat";) .fail (function (res) alert ("Error:" + res.getResponseHeader ("error"));); else alert ("Las contraseñas no coinciden") ; else alert ("Se requiere un nombre de usuario y contraseña");); Este código es casi idéntico, por lo tanto, es probable que pueda abstraer toda la parte Ajax en su propia función, pero para este tutorial está bien.
Ahora tenemos que volver a nuestro 'Controlador principal'y manejar estas dos rutas, pero antes de hacerlo, quiero instalar un módulo Node. Tendremos que cambiar la contraseña, ya que las contraseñas de texto simple son no ¡Algo bueno, ni siquiera para demostración! Encontré un bonito módulo llamado 'password-hash' por David Wood que funcionará muy bien.
Para instalarlo, simplemente vaya a la raíz de su aplicación Sails, desde su terminal y escriba: npm instalar contraseña-hash.
Una vez que se instala, vamos a abrir el Controlador principal e implementar las dos rutas necesarias. Empecemos con Regístrate:
registro: función (req, res) var username = req.param ("username"); var contraseña = req.param ("contraseña"); Users.findByUsername (username) .done (function (err, usr) if (err) res.send (500, error: "DB Error"); else if (usr) res.send (400, error: "El nombre de usuario ya está tomado"); else var hasher = require ("password-hash"); password = hasher.generate (password); Users.create (username: username, password: password). hecho (función (error, usuario) si (error) res.send (500, error: "DB Error"); else req.session.user = usuario; res.send (usuario); );); Es un poco detallado, pero todo lo que estamos haciendo aquí es leer el nombre de usuario y la contraseña de la solicitud POST y asegurarnos de que el nombre de usuario ya no esté en uso. Puedes ver que también estoy usando la herramienta de creación de contraseñas que acabamos de instalar, es muy fácil de usar, simplemente pasa la contraseña al método de generación y la procesará utilizando un salt aleatorio..
También vale la pena mencionar que en cada ubicación posible en la que podemos encontrarnos con un error o problema, estamos devolviendo un código de error HTTP y devolviendo un mensaje a través de un encabezado personalizado llamado 'error'que, si recuerdas, estamos mostrando un mensaje de alerta en la página de índice.
Otro punto notable es el hecho de que estamos usando una función 'mágica' llamada 'encontrar nombre de usuario', esto es posible porque tenemos una nombre de usuario Columna dentro de nuestro modelo de usuarios..
Finalmente, en la parte inferior puede ver si todo salió bien, estamos almacenando al usuario en una variable de sesión y devolviéndolo con un código de estado predeterminado de 200, lo que indicará a jQuery que la solicitud de AJAX fue exitosa.
A continuación, vamos a escribir la función de inicio de sesión:
login: function (req, res) var username = req.param ("username"); var contraseña = req.param ("contraseña"); Users.findByUsername (username) .done (función (err, usr) if (err) res.send (500, error: "DB Error"); else if (usr) var hasher = require ( "password-hash"); if (hasher.verify (password, usr.password)) req.session.user = usr; res.send (usr); else res.send (400, error: "Incorrecto Contraseña "); else else resend (404, error:" Usuario no encontrado ");); De nuevo, esto es muy similar al anterior. Regístrate Para ello, estamos buscando un usuario con el mismo nombre de usuario que se publicó en el formulario y, si lo encuentra, verificamos si la contraseña coincide con el uso del hasher verificar método. La razón por la que no podemos volver a escribir la contraseña y pasarla a los modelos encontrar La función se debe a que el hasher utiliza un salt aleatorio, por lo que si volvemos a usar la contraseña sería igual a otra cosa..
El resto del código es el mismo; Si todo sale bien, almacenamos al usuario en una sesión y lo devolvemos, de lo contrario, le devolvemos un mensaje de error..
El sistema de inicio de sesión ahora está completo y finalmente podemos continuar con la construcción de la función de chat..
Ya que usaremos Backbone para recibir los mensajes, la función de ruta real será muy simple. Aquí está la función de chat completa:
chat: función (req, res) if (req.session.user) res.view (username: req.session.user.username); else res.redirect ('/'); Comenzamos comprobando si el usuario ha iniciado sesión o no, si esto se verifica, se cargará la vista y se le pasará el nombre de usuario que estaba en la sesión; de lo contrario, simplemente redirigiremos a la página de inicio..
Ahora vamos a crear una nueva vista llamada 'chat.ejs'dentro de la principal carpeta. Ábralo y vamos a crear un formulario simple para publicar nuevos mensajes y un div contenedor para mostrar todos ellos.
Bienvenido <%= username %>
Así que para esta vista, solo usamos un HTML bastante estándar. Lo único que puede requerir alguna explicación es la <%= username %> código, este estilo de codificación no es específico de Sails, en realidad es la sintaxis de EJS. Esta sintaxis es muy similar a las etiquetas cortas de PHP.. <% es el equivalente de en PHP y <%= es lo mismo que . El primer fragmento de EJS le permite integrar el código JS estándar en la página, mientras que el segundo imprime el código dentro. Aquí solo estamos imprimiendo el nombre de usuario que pasamos desde el controlador.
El resto de nuestra función de chat será todo JavaScript. Para comenzar, veamos cómo escribiría la funcionalidad de chat usando Backbone estándar, y luego veremos cómo aprovechar los sockets web..
En la parte inferior de la página, agregue el siguiente JS:
Ya que Sails crea automáticamente una API que Backbone entiende de forma nativa, no se debe escribir ningún código de servidor adicional, no hay nada más fácil que eso. De esto era de lo que hablaba cuando dije que Sails no estaba hecho para ser un "marco". No intenta hacer que utilices su propia sintaxis, se hizo para hacer las cosas y, como puedes ver, ofrece.
Para probarlo, abra una ventana de terminal y navegue hasta la carpeta de su aplicación Sails, luego escriba 'elevacion de velas'para iniciarlo. Por defecto se lanzará a http: // localhost: 1337. Ahora solo regístrate y publica algunos mensajes..
Para ver tus mensajes publicados puedes console.log La variable de mensajes, o mirarla dentro de la consola del navegador. Ahora, lo siguiente que debemos implementar es una vista para que podamos ver los mensajes publicados en el navegador..
_.templateSettings = interpolate: /\\(.+?)\\/g; var MessagesView = Backbone.View.extend (el: '#messagesContainer', initialize: function () this.collection.on ('add', this.render, this); this.render ();, template: _.modelo("mensaje
"), render: function () this. $ el.html (" "); this.collection.each (function (msg) this. $ el.append (this.template (msg.toJSON ())); , this)); var mView = new MessagesView (collection: messages); Comenzamos definiendo una vista, adjuntándola al div que creamos anteriormente, luego agregamos un controlador de eventos en la colección para volver a renderizar el div cada vez que se agrega un nuevo modelo a la colección..
Se puede ver en la parte superior, tuve que cambiar la configuración de subrayado predeterminada de usar la sintaxis de EJS dentro de las plantillas, para utilizar la sintaxis de bigote. Esto se debe a que la página ya es un documento EJS, por lo que se procesaría en el servidor y no en el guión bajo..
Nota: No se me ocurrió el Regex para esto, ese crédito va a los documentos de subrayado en sí.
Por último, en la parte inferior puede ver que creamos una nueva instancia de esta vista, pasándole la variable de colección..
Si todo salió bien, ahora debería ver sus mensajes en el navegador y debería actualizarse cada vez que cree una nueva publicación..
Ahora te habrás dado cuenta de que no estamos configurando el ID de usuario o la nombre de usuario Cuando enviamos los mensajes, y esto es por razones de seguridad..
No quieres poner este tipo de control en el lado del cliente. Si todo lo que alguien tiene que hacer es modificar una variable de JavaScript para controlar la cuenta de otro usuario, tendrá un problema importante.
Entonces, ¿cómo debes manejar esto? Bueno, con políticas por supuesto..
Las políticas son básicamente middleware, que se ejecutan antes de la solicitud web real, donde puede detener, modificar o incluso redirigir la solicitud, según sea necesario..
Para esta aplicación, vamos a crear una política para nuestros mensajes. Las políticas se aplican a los controladores, por lo que incluso se pueden ejecutar en páginas normales, pero para este tutorial, solo nos quedamos con uno para nuestros mensajes Modelo.
Cree un archivo llamado 'MessagesPolicy.js' dentro de 'api> políticas'e ingrese lo siguiente:
module.exports = function (req, res, next) if (req.session.user) var action = req.param ('action'); if (action == "create") req.body.userId = req.session.user.id; req.body.username = req.session.user.username; siguiente(); else res.send ("Debes haber iniciado sesión", 403); ; Entonces, ¿qué está pasando aquí? Puede ver que esta función se parece a una función de ruta normal, aunque la diferencia es el tercer parámetro, que llamará al siguiente middleware en la pila. Si eres nuevo en la idea del middleware, puedes considerarlo como una muñeca rusa anidada. Cada capa recibe la solicitud, junto con las variables de respuesta, y pueden modificarlas según lo crea conveniente. Si pasan todos los requisitos, la capa puede pasar más allá hasta que llegue al centro, que es la función de ruta..
Así que aquí estamos, verificando si el usuario está conectado, si el usuario no lo está, mostramos un error 403 y la solicitud termina aquí. De lo contrario, (es decir, el usuario está conectado) llamamos siguiente(); para pasarlo. En medio del código anterior, es donde inyectamos algunas variables de publicación. Estamos aplicando esto a todas las llamadas en el controlador de 'mensajes' (básicamente la API), por lo que obtenemos la acción y comprobamos si esta solicitud está intentando crear un nuevo mensaje, en cuyo caso agregamos los campos de publicación para el usuario. carné de identidad y nombre de usuario.
A continuación, abre la políticas.js archivo que está en la carpeta de configuración, y agregue la política que acabamos de crear. Entonces tu archivo debería verse así:
module.exports.policies = '*': true, 'messages': 'MessagesPolicy';
Una vez implementado, tendremos que eliminar todos los registros antiguos, ya que no tienen estos nuevos datos. Entonces, cierre el servidor Sails (ctrl-c) y en el mismo tipo de ventana de terminal: rm -r .tmp para eliminar la base de datos temporal que nos da una pizarra limpia.
A continuación, agreguemos el nombre de usuario a las publicaciones reales, así que en 'chat.ejs' cambie la plantilla a:
plantilla: _.template ("nombre de usuario: mensaje
"), Reinicie el servidor de Sails (otra vez usando elevacion de velas) y regístrate otro nuevo usuario para probarlo. Si todo funciona correctamente, deberías poder agregar mensajes y ver tu nombre en la publicación..
En este punto, tenemos una configuración bastante buena, recuperamos la publicación automáticamente usando Backbone y la API, además tenemos algo de seguridad básica implementada. El problema es que no se actualizará cuando otras personas publiquen mensajes. Ahora puede resolver esto creando un intervalo de JavaScript y sondeando las actualizaciones, pero podemos hacerlo mejor.
Anteriormente mencioné que Sails aprovecha las capacidades bidireccionales de websockets para publicar actualizaciones en los datos suscritos. Usando estas actualizaciones, podemos escuchar las nuevas adiciones a la tabla de mensajes y actualizar la colección en consecuencia.
Así que en el chat.ejs archivo, vamos a crear un nuevo tipo de colección; un SailsCollection:
var SailsCollection = Backbone.Collection.extend (sailsCollection: "", socket: null, sync: function (método, modelo, opciones) var where = ; if (options.where) where = where: options. donde if (typeof this.sailsCollection === "string" && this.sailsCollection! == "") this.socket = io.connect (); this.socket.on ("connect", _.bind ( function () this.socket.request ("/" + this.sailsCollection, where, _.bind (function (users) this.set (users);, this)); this.socket.on ("message ", _.bind (función (msg) var m = msg.uri.split (" / "). pop (); if (m ===" create ") this.add (msg.data); else if (m === "update") this.get (msg.data.id) .set (msg.data); else if (m === "destroy") this.remove (this.get (msg.data.id));, this));, this)); else console.log ("Error: No se pueden recuperar modelos porque la propiedad 'sailsCollection' no está establecida en la colección"); ); Ahora puede ser largo, pero en realidad es muy simple, vamos a recorrerlo. Comenzamos agregando dos nuevas propiedades al objeto Colección, una para mantener el nombre del "modelo" de Sails y otra para mantener el socket web. A continuación, modificamos la sincronizar Si estás familiarizado con Backbone, sabrás que esta es la función que interactúa con el servidor cuando llamas cosas como ha podido recuperar. Por lo general, dispara las solicitudes de Ajax, pero vamos a personalizarlo para la comunicación de socket.
Ahora, no estamos utilizando la mayor parte de la funcionalidad que el sincronizar La función ofrece, principalmente porque no hemos agregado la capacidad para que los usuarios actualicen o eliminen mensajes, pero para completar, los incluiré en la definición de la función.
Echemos un vistazo a la primera parte de la sincronizar función:
var donde = ; if (options.where) where = where: options.where
Este código primero comprueba si hay algunodónde'Se enviaron cláusulas, esto te permitiría hacer cosas como: messages.fetch (donde: id: 4); sólo para buscar filas donde el ID es igual a cuatro.
Después de eso, tenemos un código que asegura que el 'velasColeccion'propiedad se ha establecido, de lo contrario registramos un mensaje de error. Luego, creamos un nuevo socket y nos conectamos al servidor, escuchando la conexión con el en ('conectar') evento.
Una vez conectado, solicitamos el índice de 'velasColeccion'especificado para tirar en la lista actual de modelos. Cuando recibe los datos, utilizamos la colección de conjunto Función para configurar inicialmente los modelos..
Bien, ahora hasta ahora, tenemos el equivalente de la norma ha podido recuperar mando. El siguiente bloque de código es donde suceden las notificaciones push:
this.socket.on ("message", _.bind (function (msg) var m = msg.uri.split ("/"). pop (); if (m === "create") this. add (msg.data); else if (m === "update") this.get (msg.data.id) .set (msg.data); else if (m === "destroy") this.remove (this.get (msg.data.id));, this)); Ahora la acción que se está realizando (ya sea que estemos creando, actualizando o destruyendo un mensaje) se puede encontrar dentro de la msg, que es entonces dentro de la uri. Para obtener la acción, dividimos el URI en barras diagonales ('/') y tomamos solo el último segmento usando la popular función. Luego tratamos de emparejarlo con las tres acciones posibles de crear, actualizar, o destruir.
El resto es Backbone estándar, ya sea que agregamos, editamos o eliminamos el modelo especificado. Con nuestra nueva clase casi completa, todo lo que queda por hacer es cambiar la corriente MensajeColeccion. En lugar de ampliar la colección Backbone, debe ampliar nuestra nueva colección, de esta manera:
var MessageCollection = SailsCollection.extend (sailsCollection: 'messages', model: MessageModel);
Además de ampliar nuestra nueva colección, haremos otro cambio para que, en lugar de
