comum: &comum
\nNome do host: localhost
\nporto: 8091
\nnome de usu\u00e1rio:
\nsenha:
\npool: defaultdevelopment:
\n< bucket: rvine<\/p>\n
teste:
\n< bucket: rvine<\/p>\n
# defina estas vari\u00e1veis de ambiente em seu servidor de produ\u00e7\u00e3o
\nprodu\u00e7\u00e3o:
\nnome do host: <%<\/span>= ENV[<\/span>'COUCHBASE_HOST'<\/span>]<\/span> %><\/span>
\nporto: <%<\/span>= ENV[<\/span>'COUCHBASE_PORT'<\/span>]<\/span> %><\/span>
\nnome de usu\u00e1rio: <%<\/span>= ENV[<\/span>'COUCHBASE_USERNAME'<\/span>]<\/span> %><\/span>
\nsenha: <%<\/span>= ENV[<\/span>'COUCHBASE_PASSWORD'<\/span>]<\/span> %><\/span>
\npiscina: <%<\/span>= ENV[<\/span>'COUCHBASE_POOL'<\/span>]<\/span> %><\/span>
\nbalde: <%<\/span>= ENV[<\/span>'COUCHBASE_BUCKET'<\/span>]<\/span> %><\/span><\/p>\n<\/div>\n<\/div>\nOk, agora que isso foi feito, devemos ter um projeto Rails barebone, que est\u00e1 conectado ao Couchbase como seu armazenamento de dados de backend. Parece simples? Isso \u00e9 porque o Couchbase-Model torna nossa vida 1000 vezes mais f\u00e1cil quando se trata de modelagem de dados!<\/p>\n
Agora, a pr\u00f3xima coisa que precisamos fazer \u00e9 configurar nosso Classes de usu\u00e1rio e autentica\u00e7\u00e3o.<\/em><\/strong><\/p>\nPrimeiro, vamos criar nosso modelo de usu\u00e1rio. Crie o arquivo \/app\/models\/user.rb<\/p>\n
\n
\n
classe<\/span> Usu\u00e1rio <<\/span> Couchbase::Modelo<\/span><\/p>\natributo :nome<\/span>
\natributo :twit_username<\/span>
\natributo :avatar<\/span><\/p>\ndef<\/span> aut\u00f4nomo<\/span>.find_or_create_from_auth_hash<\/span>(<\/span>hash)<\/span>
\nusu\u00e1rio = User.find_by_id<\/span>(<\/span>hash[<\/span>:uid<\/span>]<\/span>)<\/span>
\na menos que<\/span> usu\u00e1rio
\nusu\u00e1rio = User.criar<\/span>!(<\/span>:id<\/span> =><\/span> hash[<\/span>:uid<\/span>]<\/span>,
\n:nome<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:nome<\/span>]<\/span>,
\n:twit_username<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:nickname<\/span>]<\/span>,
\n:avatar<\/span> =><\/span> hash[<\/span>:info<\/span>]<\/span>[<\/span>:imagem<\/span>]<\/span>)<\/span>
\nfinal<\/span>
\nusu\u00e1rio
\nfinal<\/span>
\nfinal<\/span><\/p>\n<\/div>\n<\/div>\nO atributos<\/strong> neste documento s\u00e3o os campos que desejamos incluir em nosso documento JSON. Estamos coletando o nome do usu\u00e1rio, o nome de usu\u00e1rio do Twitter e o avatar. Precisamos fornecer uma chave exclusiva para cada usu\u00e1rio em nosso banco de dados. Nesse caso, estamos fazendo isso coletando o UID do Twitter do usu\u00e1rio e criando um hash a partir dele para gerar uma chave para o nosso documento User. \u00c9 importante lembrar que a chave de cada documento em nosso banco de dados deve ser exclusiva. Al\u00e9m disso, vale a pena observar a classe que criamos. 'find_or_create_from_auth_hash' Essa classe est\u00e1 fazendo exatamente o que diz na lata! Se existir um usu\u00e1rio, fa\u00e7a a autentica\u00e7\u00e3o dele. Se n\u00e3o existir, criamos o usu\u00e1rio com base nos detalhes do Twitter que recebemos.<\/p>\nVoc\u00ea deve ter notado que optamos por usar o Twitter-Omniauth para isso, para economizar muito tempo em vez de escrever uma classe Auth do zero! A primeira coisa a fazer aqui \u00e9 ir at\u00e9 o Twitter Dev e pegar algumas chaves de aplicativo! Se voc\u00ea nunca fez isso antes, fa\u00e7a login com sua conta do Twitter. Crie um novo aplicativo chamado \"rvine\" e, depois de fazer isso, voc\u00ea receber\u00e1 duas chaves de aplicativo.<\/p>\n
Crie um arquivo de configura\u00e7\u00e3o em config\/initializers\/omniauth.rb. Depois de criar esse arquivo, abra-o e insira o seguinte c\u00f3digo:<\/p>\n
\n
Trilhos.
aplicativo<\/span>.configura\u00e7\u00e3o<\/span>.middleware<\/span>.uso<\/span> OmniAuth::Construtor<\/span> fazer<\/span>
\nprovedor :twitter<\/span>, \"CONSUMER_KEY\"<\/span>, \"CONSUMER_SECRET\"<\/span>
\nfinal<\/span><\/div>\n<\/div>\nIsso deve significar que agora temos o Omniauth configurado com as chaves do nosso aplicativo do Twitter e quase pronto para ser usado. A pr\u00f3xima coisa que precisamos fazer \u00e9 criar uma rota em nosso aplicativo Rails para lidar com o processo de autentica\u00e7\u00e3o. Ent\u00e3o, vamos abrir nosso arquivo config\/routes.rb e digitar o seguinte:<\/p>\n
\n
partida
'\/auth\/twitter\/callback'<\/span>, :to<\/span> =><\/span> 'sessions#create'<\/span><\/div>\n<\/div>\nAgora, estamos dizendo ao Rails para enviar nosso retorno de chamada do Twitter Auth'd para nosso controlador de sess\u00f5es.... Que controlador de sess\u00f5es? Precisamos cri\u00e1-lo agora.<\/p>\n
V\u00e1 em frente e crie o arquivo app\/controllers\/sessions_controller.rb<\/em><\/p>\n\n
classe<\/span> SessionsController <<\/span> Controlador de aplicativos
\ndef<\/span> criar
\nusu\u00e1rio = User.find_or_create_from_auth_hash<\/span>(<\/span>auth_hash)<\/span>
\nsess\u00e3o[<\/span>:user_id<\/span>]<\/span> = usu\u00e1rio.id<\/span>
\nflash[<\/span>:sucesso<\/span>]<\/span> = \"Bem-vindo ao clube!\"<\/span>
\nredirect_to dashboard_path
\nfinal<\/span>protegida
\ndef<\/span> auth_hash
\nsolicita\u00e7\u00e3o.env<\/span>[<\/span>'omniauth.auth'<\/span>]<\/span>
\nfinal<\/span>
\nfinal<\/span><\/p>\n<\/div>\n<\/div>\nComo voc\u00ea pode ver nesse c\u00f3digo, nosso m\u00e9todo \"Create\" est\u00e1 chamando a classe que definimos em nosso User.rb para inicializar uma sess\u00e3o quando um usu\u00e1rio clica para se autenticar no frontend ou criar o usu\u00e1rio se ele ainda n\u00e3o existir. Uma vez autenticado, estamos redirecionando o usu\u00e1rio para o seu painel. (Que criaremos em breve!)<\/p>\n
Em seguida, vamos atualizar nosso application_controller.rb <\/em>para incluir classes auxiliares para nossa autentica\u00e7\u00e3o, inclusive um m\u00e9todo auxiliar para definir um Current_User e um m\u00e9todo auxiliar para garantir que um usu\u00e1rio esteja conectado.<\/p>\n\n
classe<\/span> Controlador de aplicativos <<\/span> ActionController::Base<\/span>
\nproteger_de_falsifica\u00e7\u00e3odef<\/span> autenticar!
\nse<\/span> signed_in?
\nretorno<\/span> verdadeiro<\/span>
\nmais<\/span>
\nflash[<\/span>:error<\/span>]<\/span> = \"Voc\u00ea n\u00e3o est\u00e1 autorizado a acessar esta p\u00e1gina\"<\/span>
\nredirect_to(<\/span>caminho_da_raiz)<\/span>
\nfinal<\/span>
\nfinal<\/span><\/p>\ndef<\/span> usu\u00e1rio_atual
\n@current_user<\/span> ||<\/span>= Usu\u00e1rio.find_by_id<\/span>(<\/span>sess\u00e3o[<\/span>:user_id<\/span>]<\/span>)<\/span>
\nfinal<\/span>
\nm\u00e9todo_ajudante :current_user<\/span><\/p>\ndef<\/span> signed_in?
\n!!current_user
\nfinal<\/span>
\nm\u00e9todo_ajudante :signed_in<\/span>?
\nfinal<\/span><\/p>\n<\/div>\n<\/div>\nEm seguida, precisamos criar o Dashboard para o qual nossos usu\u00e1rios ser\u00e3o redirecionados ap\u00f3s a autoriza\u00e7\u00e3o. Para isso, vamos usar um comando Rails Generate.<\/p>\n
\n
rails geram pain\u00e9is de controle<\/div>\n<\/div>\n
Agora, vamos abrir o arquivo app\/controladores\/dashboards_controller.rb<\/em> e digite o seguinte:<\/p>\n\n
\n
classe<\/span> DashboardsController <<\/span> Controlador de aplicativos<\/p>\ndef<\/span> show
\nfinal<\/span><\/p>\nfinal<\/span><\/p>\n<\/div>\n<\/div>\nVamos abrir nossa visualiza\u00e7\u00e3o de front-end do Dashboard e edit\u00e1-la. No meu caso, ser\u00e1 um arquivo HAML. Independentemente de voc\u00ea escolher ERB ou HAML, o arquivo ter\u00e1 praticamente a mesma apar\u00eancia! Em app\/views\/dashboards<\/em> - basta criar o arquivo show.haml ou show.erb.<\/p>\n\n
%<\/span>se\u00e7\u00e3o1TP5Bem-vindo<\/span>
\n.p\u00e1gina<\/span>–<\/span>cabe\u00e7alho
\n–<\/span> se<\/span> signed_in?
\n%<\/span>h1
\nOl\u00e1, #{current_user.name}<\/span>
\n%<\/span>p<\/span>
\n%<\/span>imagem{<\/span>:src =><\/span> current_user.avatar<\/span>, :alt<\/span> =><\/span> \"Avatar\"<\/span>}<\/span>
\n%<\/span>p<\/span>= link_to(<\/span>\"Todas as videiras\"<\/span>, \"\/vines\"<\/span>)<\/span>
\n–<\/span> mais<\/span>
\n%<\/span>h1
\nOl\u00e1, estranho
\n%<\/span>p<\/span>
\n= link_to(<\/span>\"Entre com sua conta do Twitter\"<\/span>, \"\/auth\/twitter\"<\/span>)<\/span>
\n%<\/span>p<\/span>
\n&<\/span>nbsp;<\/div>\n<\/div>\nAgora que j\u00e1 temos nosso painel de controle, precisamos configurar mais alguns roteamentos e, em seguida, podemos testar as coisas! Abra o config\/routes.rb <\/em>e adicione o seguinte:<\/p>\n\n
recurso
:dashboard<\/span><\/div>\n<\/div>\nDepois de fazer isso, salve, execute o aplicativo e autentique-se como um usu\u00e1rio.<\/p>\n
\u00d3timo! Agora podemos ver que nossa autentica\u00e7\u00e3o funciona e que nossos usu\u00e1rios t\u00eam um painel. Se abrirmos o console do Couchbase, tamb\u00e9m veremos que um usu\u00e1rio foi criado dentro do nosso bucket do Rvine!<\/p>\n
Agora que j\u00e1 temos os usu\u00e1rios e a autentica\u00e7\u00e3o instalados, vamos passar para a parte principal do aplicativo: Os v\u00eddeos do Vine! Para come\u00e7ar, precisaremos criar um modelo para os Vines. Infelizmente, o Couchbase-Model ainda n\u00e3o \u00e9 compat\u00edvel com o rails Generator nessa a\u00e7\u00e3o. Portanto, precisamos criar manualmente\u00a0 \/app\/models\/vine.rb<\/em><\/p>\nDepois de fazer isso, vamos preencher o seguinte:<\/p>\n
\n