Sign Up to your Android app with Node.js & Couchbase Mobile

Com a API do Sync Gateway, você pode se autenticar no lado do cliente como um usuário específico para replicar os dados aos quais esse usuário tem acesso. No caso da autenticação básica, o usuário já deve existir no banco de dados do Sync Gateway. Há duas maneiras de criar usuários:

No arquivo de configuração sob o usuários campo.
Na API REST do administrador.

Para fornecer uma tela de login e inscrição, é necessário configurar um servidor de aplicativos que lide com a criação de usuários, pois a porta de administração (4985) não é acessível ao público. Neste tutorial, você aprenderá a:

Use a API REST do administrador para criar um usuário.
Configure um servidor de aplicativos com o Node.js para gerenciar os usuários.
Crie uma tela de login e inscrição em um aplicativo Android de amostra para testar seu App Server.

Primeiros passos

Faça o download do Sync Gateway e descompacte o arquivo:

http://www.couchbase.com/nosql-databases/downloads#Couchbase_Mobile

Para este tutorial, você não precisará de um arquivo de configuração. Para obter propriedades básicas de configuração, você pode usar as opções da linha de comando. O binário a ser executado está localizado em ~/Downloads/couchbase-sync-gateway/bin/. Execute o programa com o comando -ajuda para ver a lista de opções disponíveis:

~/Downloads/couchbase-sync-gateway/bin/sync_gateway --help
Usage of /Users/jamesnocentini/Downloads/couchbase-sync-gateway/bin/sync_gateway:
  -adminInterface="127.0.0.1:4985": Address to bind admin interface to
  -bucket="sync_gateway": Name of bucket
  -configServer="": URL of server that can return database configs
  -dbname="": Name of Couchbase Server database (defaults to name of bucket)
  -deploymentID="": Customer/project identifier for stats reporting
  -interface=":4984": Address to bind to
  -log="": Log keywords, comma separated
  -logFilePath="": Path to log file
  -personaOrigin="": Base URL that clients use to connect to the server
  -pool="default": Name of pool
  -pretty=false: Pretty-print JSON responses
  -profileInterface="": Address to bind profile interface to
  -url="walrus:": Address of Couchbase server
  -verbose=false: Log more info about requests

~/Downloads/couchbase-sincronização-portal/caixa/portais de sincronização --ajuda

Uso de /Usuários/jamesnocentini/Downloads/couchbase-sincronização-portal/caixa/portais de sincronização:

-adminInterface="127.0.0.1:4985": Endereço para vincular administrador interface para

-balde="sync_gateway": Nome de balde

-configServer="": URL de servidor que pode retorno banco de dados configurações

-nome do usuário="": Nome de Couchbase Servidor banco de dados (padrões para nome de balde)

-ID da implantação="": Cliente/projeto identificador para estatísticas relatórios

-interface=":4984": Endereço para vincular para

-registro="": Registro palavras-chave, vírgula separados

-logFilePath="": Caminho para registro arquivo

-personaOrigin="": Base URL que clientes uso para conectar para o servidor

-piscina="default": Nome de piscina

-bonito=falso: Bonita-impressão JSON respostas

-profileInterface="": Endereço para vincular perfil interface para

-url="walrus:": Endereço de Couchbase servidor

-detalhado=falso: Registro mais informações sobre solicitações

Para este tutorial, você especificará o nome do usuário, interface, bonito e url:

~/Downloads/couchbase-sync-gateway/bin/sync_gateway -dbname="smarthome" -interface="0.0.0.0:4984" -pretty="true" -url="walrus:"

1	~/Downloads/couchbase-sincronização-portal/caixa/portais de sincronização -nome do usuário="smarthome" (casa inteligente) -interface="0.0.0.0:4984" -bonito="true" (verdadeiro) -url="walrus:"

Para criar um usuário, você pode executar o seguinte no terminal:

$ curl -vX POST -H 'Content-Type: application/json' 
       -d '{"name": "adam", "password": "letmein"}' 
       :4985/smarthome/_user/

$ enrolar -vX POST -H 'Content-Type: application/json'

-d '{"name": "adam", "password": "letmein"}'

:4985/casa inteligente/_usuário/

OBSERVAÇÃO: O campo de nome no objeto JSON não deve conter espaços.

Isso deve retornar um 201 Criado código de status. Agora, faça login como esse usuário na porta padrão:

$ curl -vX POST -H 'Content-Type: application/json' 
       -d '{"name": "adam", "password": "letmein"}' 
       :4984/smarthome/_session

$ enrolar -vX POST -H 'Content-Type: application/json'

-d '{"name": "adam", "password": "letmein"}'

:4984/casa inteligente/_session

A resposta conterá um Set-Cookie e os detalhes do usuário no corpo.

Todos os SDKs do Couchbase Mobile têm um método para especificar o nome e a senha de um usuário para autenticação, portanto, você provavelmente não precisará se preocupar em fazer essa segunda solicitação de login.

Servidor de aplicativos

Nesta seção, você usará o /_usuário Ponto de extremidade da API REST do administrador publicamente para permitir que os usuários se inscrevam por meio do aplicativo.

Você usará o popular Expresso para tratar a solicitação de criação de um usuário e o módulo solicitação para fazer proxy de todos os outros tráfegos para o Sync Gateway.

Instale os seguintes módulos do Node.js:

npm install express body-parser request http-proxy --save

1	npm instalar expresso corpo-analisador solicitação http-proxy --salvar

Abrir um novo arquivo servidor.js e adicione o seguinte:

var express = require('express')
  , bodyParser = require('body-parser')
  , request = require('request').defaults({json: true})
  , httpProxy = require('http-proxy');

// 1
var app = express();
app.use('/signup', bodyParser.json());

// 2
app.post('/signup', function (req, res) {
  console.log('its signup time');

  var json = req.body;
  var options = {
    url: 'http://0.0.0.0:4985/smarthome/_user/',
    method: 'POST',
    body: json
  };

  request(options, function(error, response) {
    res.writeHead(response.statusCode);
    res.end();
  });
});

// 3
app.all('*', function(req, res) {
  var url = 'http://0.0.0.0:4984' + req.url;
  req.pipe(request(url)).pipe(res);
});

// 4
var server = app.listen(8000, function () {
  var host = server.address().address;
  var port = server.address().port;

  console.log('App listening at http://%s:%s', host, port);
});

var expresso = exigir("expresso)

, bodyParser = exigir('body-parser')

, solicitação = exigir("solicitação).padrões({json: verdadeiro})

, httpProxy = exigir('http-proxy');

// 1

var aplicativo = expresso();

aplicativo.uso('/signup', bodyParser.json());

// 2

aplicativo.postagem('/signup', função (req, res) {

console.registro('é hora de se registrar');

var json = req.corpo;

var opções = {

url: 'http://0.0.0.0:4985/smarthome/_user/',

método: 'POST',

corpo: json

};

solicitação(opções, função(erro, resposta) {

res.writeHead(resposta.statusCode);

res.final();

});

// 3

aplicativo.todos('*', função(req, res) {

var url = 'http://0.0.0.0:4984' + req.url;

req.tubulação(solicitação(url)).tubulação(res);

});

// 4

var servidor = aplicativo.ouvir(8000, função () {

var hospedeiro = servidor.endereço().endereço;

var porto = servidor.endereço().porto;

console.registro('App listening em http://%s:%s', hospedeiro, porto);

});

Veja a seguir o que está acontecendo, passo a passo:

Instanciar uma nova instância do express e usar o bodyParser middleware somente se o caminho corresponder a registro. De fato, para todas as outras solicitações enviadas ao Sync Gateway, você precisa do corpo bruto da solicitação.
Manuseie o /signup e usar o módulo de solicitação para criar o usuário na porta de administração.
Proxy de todas as outras solicitações para o Sync Gateway.
Inicie o servidor da Web Node.js na porta 8000.

De agora em diante, você usará a url abaixo para criar usuários por meio do aplicativo e iniciar réplicas push/pull:

http://localhost:8000

Crie outro usuário para testar se tudo está funcionando como esperado:

$ curl -vX POST -H 'Content-Type: application/json' 
       -d '{"name": "andy", "password": "letmein"}' 
       :8000/signup/

$ enrolar -vX POST -H 'Content-Type: application/json'

-d '{"name": "andy", "password": "letmein"}'

:8000/registro/

E para fazer login como esse usuário:

$ curl -vX POST -H 'Content-Type: application/json' 
       -d '{"name": "andy", "password": "letmein"}' 
       :8000/smarthome/_session

$ enrolar -vX POST -H 'Content-Type: application/json'

-d '{"name": "andy", "password": "letmein"}'

:8000/casa inteligente/_session

Na próxima seção, você criará um aplicativo Android simples com uma tela de login e inscrição para testar esses endpoints.

Aplicativo para Android

Abra o Android Studio e selecione Iniciar um novo projeto do Android Studio do Início rápido menu.

Nomear o aplicativo SmartHomedefina um domínio da empresa e um local do projeto adequados e clique em Próximo:

Na caixa de diálogo Target Android Devices (Dispositivos Android de destino), certifique-se de marcar Telefone e tabletdefina o SDK mínimo como API 22: Android 5.1 (Lollipop) para ambos, e clique em Próximo:

No dia seguinte Adicionar uma atividade ao Mobile selecione Add Atividade em branco e nomeie a atividade Atividade de boas-vindas:

Para criar as funcionalidades de registro e login, você usará duas dependências:

Biblioteca de suporte ao design do AndroidPara ter componentes de texto de entrada que sigam a especificação do Material Design.
OkHttppara lidar com as solicitações POST para /signup e /smarthome/_session.

Em build.gradleadicione essas dependências:

compile 'com.android.support:design:22.2.1'
compile 'com.squareup.okhttp:okhttp:2.3.0'

1 2	compilar 'com.android.support:design:22.2.1' compilar 'com.squareup.okhttp:okhttp:2.3.0'

Em activity_welcome.xmlAdicione o seguinte LinearLayout dentro do RelativeLayout:


    <button style="?android: attr/borderlessButtonStyle;">
    </button><button style="?android: attr/borderlessButtonStyle;">
</button>

<botão estilo="?android: attr/borderlessButtonStyle;">

</botão><botão estilo="?android: attr/borderlessButtonStyle;">

</botão>

Observe que ambos os botões têm um onClick atributo. Mova o cursor do mouse sobre um dos métodos e use o botão alt + enter > Criar openLoginActivity(view) para criar esse método no WelcomeActivity:

Faça o mesmo com o Registrar-se botão.

Em seguida, crie duas novas classes e layouts XML usando o Atividade em branco modelo. Um deles deve ser chamado Login e o outro Registrar-se:

De volta ao openLoginActivity e openSignUpActivity adicione as seguintes intenções explícitas:

public void openLoginActivity(View view) {
    Intent intent = new Intent(this, Login.class);
    startActivity(intent);
}

public void openSignUpActivity(View view) {
    Intent intent = new Intent(this, SignUp.class);
    startActivity(intent);
}

público vazio openLoginActivity(Ver visualização) {

Intenção intenção = novo Intenção(este, Login.classe);

startActivity(intenção);

}

público vazio openSignUpActivity(Ver visualização) {

Intenção intenção = novo Intenção(este, Registrar-se.classe);

startActivity(intenção);

}

Alterar a classe pai de Login.java e SignUp.java de AppCompatActivity para Atividade.

Em res/values/styles.xml (v21), altere o tema principal para Theme.AppCompat.Light.DarkActionBar.

Aberto activity_sign_up.xml e adicione o seguinte dentro do RelativeLayout tag:



        

        

            
        

        

            
        

        

            
        

        <button style="?android: attr/borderlessButtonStyle;">

    </button>

<botão estilo="?android: attr/borderlessButtonStyle;">

</botão>

Agora, execute o aplicativo e selecione a opção Registrar-se você verá os elementos EditText do Material Design.

Crie uma nova classe java chamada Ajudante de rede com o seguinte:

public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

Call post(String url, String json, Callback callback) {
    RequestBody body = RequestBody.create(JSON, json);
    Request request = new Request.Builder()
            .url(url)
            .post(body)
            .build();
    Call call = client.newCall(request);
    call.enqueue(callback);
    return call;
}

público estático final Tipo de mídia JSON = Tipo de mídia.analisar("application/json; charset=utf-8");

OkHttpClient cliente = novo OkHttpClient();

Chamada postagem(Cordas url, Cordas json, Retorno de chamada retorno de chamada) {

Corpo da solicitação corpo = Corpo da solicitação.criar(JSON, json);

Solicitação solicitação = novo Solicitação.Construtor()

.url(url)

.postagem(corpo)

.construir();

Chamada chamada = cliente.newCall(solicitação);

chamada.enfileirar(retorno de chamada);

retorno chamada;

}

Antes de poder fazer uma solicitação HTTP em seu aplicativo Android, você precisa primeiro adicionar o Rede permissão em AndroidManifest.xml:

Agora de volta ao SignUp.javaAdicione as seguintes propriedades:

NetworkHelper networkHelper = new NetworkHelper();

EditText nameInput;
EditText passwordInput;
EditText confirmPasswordInput;

Ajudante de rede Ajudante de rede = novo Ajudante de rede();

EditText nameInput;

EditText passwordInput;

EditText confirmPasswordInput;

Defina o EditText componentes no onCreate método:

nameInput = (EditText) findViewById(R.id.nameInput);
passwordInput = (EditText) findViewById(R.id.passwordInput);
confirmPasswordInput = (EditText) findViewById(R.id.confirmPasswordInput);

nameInput = (EditText) findViewById(R.id.nameInput);

passwordInput = (EditText) findViewById(R.id.passwordInput);

confirmPasswordInput = (EditText) findViewById(R.id.confirmPasswordInput);

Implementar o registro para enviar uma solicitação POST para :8000/assinatura com o nome e a senha fornecidos:

public void signup(View view) {
    if (!passwordInput.getText().toString().equals(confirmPasswordInput.getText().toString())) {
        Toast.makeText(getApplicationContext(), "The passwords do not match", Toast.LENGTH_LONG).show();
    } else {
        String json = "{"name": "" + nameInput.getText() + "", "password":"" + passwordInput.getText() + ""}";
        networkHelper.post("http://10.0.3.2:8000/signup", json, new Callback() {
            @Override
            public void onFailure(Request request, IOException e) {
            }
            @Override
            public void onResponse(Response response) throws IOException {
                String responseStr = response.body().string();
                final String messageText = "Status code : " + response.code() +
                        "n" +
                        "Response body : " + responseStr;
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(getApplicationContext(), messageText, Toast.LENGTH_LONG).show();
                    }
                });
            }
        });
    }
}

público vazio registro(Ver visualização) {

se (!passwordInput.getText().toString().iguais(confirmPasswordInput.getText().toString())) {

Torradas.makeText(getApplicationContext(), "As senhas não correspondem", Torradas.LENGTH_LONG).show();

} mais {

Cordas json = "{"nome": "" + nameInput.getText() + "", "senha":"" + passwordInput.getText() + ""}";

Ajudante de rede.postagem("http://10.0.3.2:8000/signup", json, novo Retorno de chamada() {

@Substituir

público vazio onFailure(Solicitação solicitação, IOException e) {

}

@Substituir

público vazio onResponse(Resposta resposta) lançamentos IOException {

Cordas responseStr = resposta.corpo().string();

final Cordas messageText = "Código de status : " + resposta.código() +

"n" +

"Corpo da resposta: " + responseStr;

runOnUiThread(novo Executável() {

@Substituir

público vazio executar() {

Torradas.makeText(getApplicationContext(), messageText, Torradas.LENGTH_LONG).show();

}

});

}

});

}

Execute o aplicativo e digite um nome e uma senha. Se a conta de usuário tiver sido criada com sucesso, você receberá de volta uma mensagem 201 Criado e deverá ver o usuário recém-criado no painel do administrador:

Por fim, vamos terminar com a tela de login. Em activity_login.xml, adicione o seguinte em RelativeLayout:


    
    
        
    
    
        
    
    <button style="?android: attr/borderlessButtonStyle;">
</button>

<botão estilo="?android: attr/borderlessButtonStyle;">

</botão>

Adicione as propriedades a Login.java:

NetworkHelper networkHelper = new NetworkHelper();

EditText nameInput;
EditText passwordInput;

Ajudante de rede Ajudante de rede = novo Ajudante de rede();

EditText nameInput;

EditText passwordInput;

E faça a mesma operação de vinculação de exibição em onCreate:

nameInput = (EditText) findViewById(R.id.nameInput);
passwordInput = (EditText) findViewById(R.id.passwordInput);

1 2	nameInput = (EditText) findViewById(R.id.nameInput); passwordInput = (EditText) findViewById(R.id.passwordInput);

Implementar o login método:

public void login(View view) {
    String json = "{"name": "" + nameInput.getText() + "", "password":"" + passwordInput.getText() + ""}";
    networkHelper.post("http://10.0.3.2:8000/smarthome/_session", json, new Callback() {
        @Override
        public void onFailure(Request request, IOException e) {
        }
        @Override
        public void onResponse(Response response) throws IOException {
            String responseStr = response.body().string();
            final String messageText = "Status code : " + response.code() +
                    "n" +
                    "Response body : " + responseStr;
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(getApplicationContext(), messageText, Toast.LENGTH_LONG).show();
                }
            });
        }
    });
}

público vazio login(Ver visualização) {

Cordas json = "{"nome": "" + nameInput.getText() + "", "senha":"" + passwordInput.getText() + ""}";

Ajudante de rede.postagem("http://10.0.3.2:8000/smarthome/_session", json, novo Retorno de chamada() {

@Substituir

público vazio onFailure(Solicitação solicitação, IOException e) {

}

@Substituir

público vazio onResponse(Resposta resposta) lançamentos IOException {

Cordas responseStr = resposta.corpo().string();

final Cordas messageText = "Código de status : " + resposta.código() +

"n" +

"Corpo da resposta: " + responseStr;

runOnUiThread(novo Executável() {

@Substituir

público vazio executar() {

Torradas.makeText(getApplicationContext(), messageText, Torradas.LENGTH_LONG).show();

}

});

}

});

}

Execute o aplicativo e faça login com o nome de usuário e a senha que você escolheu anteriormente. Se a autenticação for bem-sucedida, você receberá de volta um código de status 200 OK:

OBSERVAÇÃO: Todos os SDKs do Couchbase Lite têm um método no Replicação que recebe um nome e uma senha e realiza a autenticação para você, de modo que você provavelmente não precisará fazer essa solicitação POST para /smarthome/_session.

Conclusão

Neste tutorial, você aprendeu a usar a API REST do Admin para criar usuários por meio de uma tela de inscrição em um aplicativo Android.

James Nocentini, redator técnico, celular, Couchbase

Um comentário

Miguel Angel Diaz Lopez abril 25, 2017 em 12:58 pm

Post incrível! Tenho uma dúvida, como posso conectar o Couchbase Sync Gateway a outro repositório como active directory, etc. ou existe uma maneira de obter um Single Sign On entre o Sync Gateway e o Couchbase Server?

Acesse para responder

Deixar uma resposta Cancelar resposta

Você precisa fazer o login para publicar um comentário.

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Adição de inscrição de usuário ao seu aplicativo Android com Node.js e Couchbase Mobile

Primeiros passos

Servidor de aplicativos

Aplicativo para Android

Conclusão

Autor

Postado por James Nocentini, redator técnico, celular, Couchbase

Um comentário

Deixar uma resposta Cancelar resposta