com\u00fan: &com\u00fan
\nnombre de host: localhost
\npuerto: 8091
\nnombre de usuario:
\ncontrase\u00f1a:
\npiscina: defaultdevelopment:
\n< bucket: rvine<\/p>\n
prueba:
\n< bucket: rvine<\/p>\n
# establezca estas variables de entorno en su servidor de producci\u00f3n
\nproducci\u00f3n:
\nnombre de host: <%<\/span>= ENV[<\/span>COUCHBASE_HOST<\/span>]<\/span> %><\/span>
\npuerto: <%<\/span>= ENV[<\/span>PUERTO_BASE_COUCH<\/span>]<\/span> %><\/span>
\nnombre de usuario: <%<\/span>= ENV[<\/span>COUCHBASE_USERNAME<\/span>]<\/span> %><\/span>
\ncontrase\u00f1a: <%<\/span>= ENV[<\/span>COUCHBASE_PASSWORD<\/span>]<\/span> %><\/span>
\npiscina: <%<\/span>= ENV[<\/span>'COUCHBASE_POOL'<\/span>]<\/span> %><\/span>
\ncubo: <%<\/span>= ENV[<\/span>COUCHBASE_BUCKET<\/span>]<\/span> %><\/span><\/p>\n<\/div>\n<\/div>\nBien, una vez hecho esto, deber\u00edamos tener un proyecto Rails barebone conectado a Couchbase como almac\u00e9n de datos backend. \u00bfParece sencillo? Pues porque Couchbase-Model nos hace la vida 1000 veces m\u00e1s f\u00e1cil a la hora de modelar datos.<\/p>\n
Ahora, lo siguiente que tenemos que hacer es configurar nuestro Clases de usuario y autenticaci\u00f3n.<\/em><\/strong><\/p>\nVamos a crear nuestro modelo de usuario en primer lugar. Crea el archivo \/app\/models\/user.rb<\/p>\n
\n
\n
clase<\/span> Usuario <<\/span> Couchbase::Modelo<\/span><\/p>\natributo :nombre<\/span>
\natributo :twit_username<\/span>
\natributo :avatar<\/span><\/p>\ndef<\/span> auto<\/span>.find_or_create_from_auth_hash<\/span>(<\/span>hash)<\/span>
\nusuario = Usuario.buscar_por_id<\/span>(<\/span>hash[<\/span>:uid<\/span>]<\/span>)<\/span>
\na menos que<\/span> usuario
\nusuario = Usuario.crear<\/span>!(<\/span>:id<\/span> =><\/span> hash[<\/span>:uid<\/span>]<\/span>,
\n:nombre<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:nombre<\/span>]<\/span>,
\n:twit_username<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:apodo<\/span>]<\/span>,
\n:avatar<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:imagen<\/span>]<\/span>)<\/span>
\nfin<\/span>
\nusuario
\nfin<\/span>
\nfin<\/span><\/p>\n<\/div>\n<\/div>\nEn atributos<\/strong> en este documento son los campos que deseamos incluir en nuestro documento JSON. Estamos recogiendo el nombre del usuario, nombre de usuario de Twitter y Avatar. Necesitamos dar una clave \u00fanica a cada usuario en nuestra base de datos. En este caso, lo estamos haciendo mediante la recopilaci\u00f3n de Twitter UID del usuario y la creaci\u00f3n de un hash de que para generar una clave para nuestro documento de usuario. Es importante recordar que la clave de cada documento en nuestra base de datos debe ser \u00fanica. Tambi\u00e9n, vale la pena se\u00f1alar la clase que hemos creado. Esta clase hace exactamente lo que dice en la lata. Si un usuario existe, lo autentica. Si no, crearlos a partir de los datos de Twitter que recibimos.<\/p>\nHabr\u00e1s notado que hemos elegido usar Twitter-Omniauth para esto, \u00a1para ahorrarnos un mont\u00f3n de tiempo en lugar de escribir una clase Auth desde cero! Lo primero que hay que hacer es ir a Twitter Dev y coger algunas claves de aplicaci\u00f3n. Si nunca has hecho esto antes, inicia sesi\u00f3n con tu cuenta de Twitter. Crea una nueva aplicaci\u00f3n llamada 'rvine' y una vez que lo hayas hecho, se te presentar\u00e1n 2 claves de aplicaci\u00f3n.<\/p>\n
Crea un archivo de configuraci\u00f3n en config\/initializers\/omniauth.rb. Una vez creado este archivo, \u00e1brelo e introduce el siguiente c\u00f3digo:<\/p>\n
\n
Rieles.
aplicaci\u00f3n<\/span>.config<\/span>.middleware<\/span>.utilice<\/span> OmniAuth::Constructor<\/span> do<\/span>
\nproveedor :twitter<\/span>, \"CONSUMER_KEY\"<\/span>, \"CONSUMER_SECRET\"<\/span>
\nfin<\/span><\/div>\n<\/div>\nEsto deber\u00eda significar que ya tenemos Omniauth configurado con nuestras claves de aplicaci\u00f3n de Twitter, y casi listo para funcionar. Lo siguiente que tenemos que hacer es crear una ruta en nuestra aplicaci\u00f3n Rails para gestionar el proceso de autenticaci\u00f3n. Abrimos nuestro archivo config\/routes.rb e introducimos lo siguiente:<\/p>\n
\n
match
\/auth\/twitter\/callback<\/span>, :to<\/span> =><\/span> sesiones#create<\/span><\/div>\n<\/div>\nAhora le estamos diciendo a Rails que env\u00ede nuestra llamada de retorno de Twitter Auth'd a nuestro controlador de sesiones.... \u00bfQu\u00e9 controlador de sesiones? Tenemos que crearlo ahora.<\/p>\n
Sigue adelante y crea el archivo app\/controllers\/sessions_controller.rb<\/em><\/p>\n\n
clase<\/span> Controlador de sesiones <<\/span> Controlador de aplicaci\u00f3n
\ndef<\/span> crear
\nusuario = Usuario.find_or_create_from_auth_hash<\/span>(<\/span>auth_hash)<\/span>
\nsesi\u00f3n[<\/span>:user_id<\/span>]<\/span> = usuario.id<\/span>
\nflash[<\/span>:\u00e9xito<\/span>]<\/span> = \"\u00a1Bienvenido al club!\"<\/span>
\nredirect_to dashboard_path
\nfin<\/span>protegido
\ndef<\/span> auth_hash
\nsolicitud.env<\/span>[<\/span>omniauth.auth<\/span>]<\/span>
\nfin<\/span>
\nfin<\/span><\/p>\n<\/div>\n<\/div>\nComo se puede ver en este c\u00f3digo, nuestro m\u00e9todo 'Create' est\u00e1 llamando a la clase que definimos en nuestro User.rb para inicializar una sesi\u00f3n cuando un usuario hace clic para autenticarse desde el frontend, o crear el usuario si a\u00fan no existe. Una vez autenticado, redirigimos al usuario a su panel de control. (\u00a1Que crearemos pronto!)<\/p>\n
A continuaci\u00f3n, vamos a actualizar nuestro application_controller.rb <\/em>para incluir clases de ayuda para nuestra Autenticaci\u00f3n - incluyendo un m\u00e9todo de ayuda para definir un Current_User y un m\u00e9todo de ayuda para asegurar que un Usuario est\u00e1 Registrado.<\/p>\n\n
clase<\/span> Controlador de aplicaci\u00f3n <<\/span> ActionController::Base<\/span>
\nproteger_de_falsificacionesdef<\/span> \u00a1Autenticar!
\nsi<\/span> signed_in?
\ndevolver<\/span> verdadero<\/span>
\nsi no<\/span>
\nflash[<\/span>:error<\/span>]<\/span> = \"No est\u00e1 autorizado a acceder a esta p\u00e1gina\"<\/span>
\nredirigir_a(<\/span>ruta_raiz)<\/span>
\nfin<\/span>
\nfin<\/span><\/p>\ndef<\/span> usuario_actual
\n@usuario_actual<\/span> ||<\/span>= Usuario.buscar_por_id<\/span>(<\/span>sesi\u00f3n[<\/span>:user_id<\/span>]<\/span>)<\/span>
\nfin<\/span>
\nm\u00e9todo_ayudante :usuario_actual<\/span><\/p>\ndef<\/span> signed_in?
\nUsuario_actual
\nfin<\/span>
\nm\u00e9todo_ayudante :signed_in<\/span>?
\nfin<\/span><\/p>\n<\/div>\n<\/div>\nA continuaci\u00f3n tenemos que crear el panel de control al que se redirigir\u00e1 a nuestros usuarios una vez autorizados. Para ello usaremos un comando Rails Generate.<\/p>\n
\n
rails genera cuadros de mando de controladores<\/div>\n<\/div>\n
Ahora, vamos a abrir el archivo app\/controllers\/dashboards_controller.rb<\/em> e introduce lo siguiente:<\/p>\n\n
\n
clase<\/span> Cuadros de mandoController <<\/span> Controlador de aplicaci\u00f3n<\/p>\ndef<\/span> Mostrar
\nfin<\/span><\/p>\nfin<\/span><\/p>\n<\/div>\n<\/div>\nVamos a abrir nuestra vista frontend del Dashboard, y editar eso. En mi caso, va a ser un archivo HAML. Independientemente de que elijas ERB o HAML, el archivo va a tener pr\u00e1cticamente el mismo aspecto. En app\/views\/paneles de control<\/em> - basta con crear el archivo show.haml o show.erb.<\/p>\n\n
%<\/span>secci\u00f3n1TP5Bienvenido<\/span>
\n.p\u00e1gina<\/span>–<\/span>cabecera
\n–<\/span> si<\/span> signed_in?
\n%<\/span>h1
\nHola, #{current_user.name}<\/span>
\n%<\/span>p<\/span>
\n%<\/span>img{<\/span>:src =><\/span> usuario_actual.avatar<\/span>, :alt<\/span> =><\/span> \"Avatar\"<\/span>}<\/span>
\n%<\/span>p<\/span>= enlace_a(<\/span>\"Todas las vides\"<\/span>, \"\/vines\"<\/span>)<\/span>
\n–<\/span> si no<\/span>
\n%<\/span>h1
\nHola, forastero
\n%<\/span>p<\/span>
\n= enlace_a(<\/span>\"Inicia sesi\u00f3n con tu cuenta de twitter\"<\/span>, \"\/auth\/twitter\"<\/span>)<\/span>
\n%<\/span>p<\/span>
\n&<\/span>nbsp;<\/div>\n<\/div>\nAhora que ya tenemos nuestro panel de control, tenemos que configurar algunas rutas m\u00e1s, y luego podemos seguir adelante y probar las cosas. Abrir config\/rutas.rb <\/em>y a\u00f1ade lo siguiente:<\/p>\n\n
recurso
:salpicadero<\/span><\/div>\n<\/div>\nUna vez hecho esto, guarda, ejecuta tu aplicaci\u00f3n y autentif\u00edcate como usuario.<\/p>\n
Perfecto. Ahora podemos ver que nuestra Autenticaci\u00f3n funciona, y nuestros Usuarios tienen un Dashboard. Si abrimos nuestra consola de Couchbase, \u00a1tambi\u00e9n deber\u00edamos ver que se ha creado un Usuario dentro de nuestro bucket de Rvine!<\/p>\n
Ahora que tenemos nuestros usuarios y autenticaci\u00f3n en su lugar, vamos a pasar a la parte principal de la aplicaci\u00f3n: \u00a1Los videos de Vine! Para empezar, vamos a necesitar crear un modelo para Vines. Ahora, desafortunadamente, Couchbase-Model todav\u00eda no soporta el Generador de rails en esta acci\u00f3n. As\u00ed que tenemos que crear manualmente\u00a0 \/app\/models\/vine.rb<\/em><\/p>\nUna vez hecho esto, vamos a rellenar lo siguiente:<\/p>\n
\n