Formato REST de login do usuário

Alguém tem um Login REST funcionando no Drupal 8?

Isto é o que eu tentei.

POST /user/login HTTP/1.1
Host: 8.d8.local
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: http://nikhilmohan.in
Cache-Control: no-cache

name=test&pass=password&form_id=user_login_form

Ele me retorna HTML em vez de JSON .

A partir da 8.2, o Drupal suporta pontos de extremidade json para autenticação de cookies. Você não precisa mais postar o formulário 🎉

curl --header "Content-type: application/json" --request POST \
  --data '{"name":"admin", "pass":"admin"}' \
http://drupal.d8/user/login?_format=json

A saída será semelhante

{"current_user":{"uid":"1","roles":["authenticated","administrator"],"name":"admin"},"csrf_token":"wBr9ldleaUhmP4CgVh7PiyyxgNn_ig8GgAan9-Ul3Lg","logout_token":"tEulBvihW1SUkrnbCERWmK2jr1JEN_mRAQIdNNhhIDc"}

Alterar registro: https://www.drupal.org/node/2720655

Outros métodos de autenticação: https://www.drupal.org/docs/8/core/modules/rest/using-other-authentication-protocols

Veja como você pode fazer login via JavaScript para o Drupal 8 REST:

Drupal 8.2 e além

• POST :http://example.com/user/login?_format=json
• Tipo de conteúdo :application/json
• Dados :{ "name": "admin", "pass": "myPassword" }
• Resposta :200 OK

Isso fará o login corretamente via autenticação de cookie e retornará um resultado semelhante a este:

{
  "current_user": {
    "uid":"1",
    "roles":["authenticated"],
    "name":"admin"
  },
  "csrf_token":"abc123",
  "logout_token":"def456"
}

Criei um módulo contrib chamado jDrupal que facilita o login com JavaScript (entre outras coisas):

// Login and show the user their id.
jDrupal.userLogin('admin', 'myPassword').then(function() {
  alert(jDrupal.currentUser().id());
});

Antes do Drupal 8.2

• POSTAR :http://example.com/user/login
• Tipo de conteúdo :application/x-www-form-urlencoded
• Dados :name=admin&pass=myPassword&form_id=user_login_form
• Resposta :200 OK | 303 See Other

Você enviará os dados junto no URL como uma string de consulta. O resultado será HTML, portanto, ele não retornará nada útil para você, mas fará o login adequado via autenticação de cookie.

1. Uma solicitação HTTP não é RESTful com base no Tipo de Conteúdo.
2. " Login REST " é tecnicamente um oxímoro.

Autenticação RESTful significa enviar autenticação com cada solicitação porque é sem estado. O exemplo fornecido pelo núcleo do Drupal 8 é o módulo Autenticação básica, que permite enviar credenciais de autenticação para uma solicitação HTTP via autenticação HTTP básica, concedendo a um usuário permissão para acessar o conteúdo via GET.

Exemplo RESTful

Ondulação: curl -vvv -k -H "Authorization: Basic test:password" http://8.d8.local/node/1?_format=json

GET /node/1?_format=json HTTP/1.1
Host: 8.d8.local
User-Agent: curl/7.43.0
Accept: */*
Authorization: Basic test:password

No entanto, isso geralmente não é bom o suficiente. Os simple_oauth e oauth módulos contrib fornecer suporte OAuth 2 e 1 respectivamente., Com o qual um pedido HTTP pode ser feita com a autenticação OAuth fichas com base no trabalho OAuth fluxos descrito nos módulos.

Mas a verdadeira questão parece ser

Como faço para entrar por meio de uma API de serviços da Web?

Não há um módulo Drupal 8 estável para fazer isso, mas os Serviços módulo fornece métodos para criar ações não RESTful e ações direcionadas, como "login".

O seguinte funciona após a configuração de um terminal chamado "api":

Ondulação: curl -vvv -k -H "Content-Type: application/json" -H "Accept: application/json" -d '{"username": "test", "password": "password"}' http://8.d8.local/api/user/login

POST /api/user/login HTTP/1.1
Host: 8.d8.local
Accept: application/json
Content-Type: application/json
Content-Length: 44

{"username": "test", "password": "password"}

Isso retorna o ID e o nome da sessão JSON (também configurada no cabeçalho Set-Cookie da resposta).

e também você pode fazer login com a chamada Jquery ajax com o seguinte trecho

$.ajax({
    url : "http://gttc.dd:8083/user/login",
    type : 'post',
    data : 'form_id=user_login_form&name=' + encodeURIComponent("username") + '&pass=' + encodeURIComponent("password"),
    dataType : 'json',
    error : function(data) {
            //error code
    },
    success : function(data) {
      console.log(data);
        //success code
    }
});

Versão do Drupal Core: 8.x-4.x

Você precisa habilitar o serviço de login do usuário, o que pode ser feito de várias maneiras. Prefiro usar o módulo REST UI .

Vá para / admin / config / services / rest e ative o recurso Restante do Usuário .

Uma vez ativado, você pode acessar / admin / config / services / rest / resource / entity% 3Auser / edit clicando em Editar ao lado do recurso Usuário . Certifique-se de ativar o método GET .

Agora que você tem tudo configurado, pode começar a usar o serviço executando este comando no terminal ou usando qualquer aplicativo para solicitações de curl, como: clientes Postman e Restlet .

NOTA : O token CSRF pode ser obtido em: / rest / session / token

curl -i -L -X POST \
  -H "Content-Type:application/json" \
  -H "Accept:application/json" \
  -H "X-CSRF-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \
  -d \
     '{
       "name": "my_username",
       "pass": "my_password"
     }' \
'http://SITE-URL/user/login?_format=json'

Os objetos de retorno são os seguintes:

SUCESSO :

{
  "current_user": {
  "uid": "1",
    "roles": [
      "authenticated"
    ],
    "name": "Admin"
  },
  "csrf_token": "bbbbbbbbbbbbbbbbbbbbbbbbbb",
  "logout_token": "ccccccccccccccccccccccccc"
}

FALHA :

{
  "message":"Sorry, unrecognized username or password."
}

Eu uso o login RESTFul personalizado no drupal 8, mas não com o cookie. É para um aplicativo móvel e sempre que preciso de informações, uso um simples Autenticar:

Desde o Drupal 8.2x, precisamos de 2 arquivos em um módulo:

rest.ressource.user.rest_ressource.yml na pasta config / install

langcode: en
status: true
dependencies:
  module:
    - basic_auth
id: user.rest_ressource
plugin_id: 'user_rest_ressource'
granularity: resource
configuration:
  methods:
    - GET
    - PATCH
  formats:
    - json
  authentication:
    - basic_auth

Você pode adicionar mais métodos como DELETE / POST

Então precisamos do arquivo

userRestRessource.php em src / Plugin / rest / resource

    <?php

    namespace Drupal\yourmodule\Plugin\rest\resource;

    use Drupal\Core\Session\AccountProxyInterface;
    use Drupal\rest\Plugin\ResourceBase;
    use Drupal\rest\ResourceResponse;
    use Symfony\Component\DependencyInjection\ContainerInterface;
    use Psr\Log\LoggerInterface;


    /**
     * Provides a resource to get view modes by entity and bundle.
     *
     * @RestResource(
     *   id = "user_rest_ressource",
     *   label = @Translation("User Rest"),
     *   uri_paths = {
     *     "canonical" = "/api/user/getInfo"
     *   }
     * )
     */
    class UserRestRessource extends ResourceBase {

      /**
       * A current user instance.
       *
       * @var \Drupal\Core\Session\AccountProxyInterface
       */
      protected $currentUser;

      /**
       * Constructs a Drupal\rest\Plugin\ResourceBase object.
       *
       * @param array $configuration
       *   A configuration array containing information about the plugin instance.
       * @param string $plugin_id
       *   The plugin_id for the plugin instance.
       * @param mixed $plugin_definition
       *   The plugin implementation definition.
       * @param array $serializer_formats
       *   The available serialization formats.
       * @param \Psr\Log\LoggerInterface $logger
       *   A logger instance.
       * @param \Drupal\Core\Session\AccountProxyInterface $current_user
       *   A current user instance.
       */
      public function __construct(
        array $configuration,
        $plugin_id,
        $plugin_definition,
        array $serializer_formats,
        LoggerInterface $logger,
        AccountProxyInterface $current_user) {
        parent::__construct($configuration, $plugin_id, $plugin_definition, $serializer_formats, $logger);

        $this->currentUser = $current_user;

      }

      /**
       * {@inheritdoc}
       */
      public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
        return new static(
          $configuration,
          $plugin_id,
          $plugin_definition,
          $container->getParameter('serializer.formats'),
          $container->get('logger.factory')->get('yourmodulename'),
          $container->get('current_user')
        );
      }

      /**
       * Responds to GET requests.
       *
       * Returns a list of bundles for specified entity.
       *
       * @throws \Symfony\Component\HttpKernel\Exception\HttpException
       *   Throws exception expected.
       */
      public function get() {

          $uid=$this->currentUser->getAccount()->id();
          $role=$this->currentUser->getAccount()->getRoles(1);

//here you can add your custom code
 $responseResource=new ResourceResponse(
          array()

      );
        return $responseResource;
      }

        /**
         * Responds to PATCH requests.
         *
         * Returns a list of bundles for specified entity.
         *
         * @throws \Symfony\Component\HttpKernel\Exception\HttpException
         *   Throws exception expected.
         */
        public function patch(){

        }

    }

Não se esqueça de ir ao usuário certo para aceitar o método GET / POST ou qualquer outra coisa que você adicionou na sua configuração.

Com isso, você pode criar todos os arquivos REST customizados para cada entidade customizada.

E no meu js: não se esqueça de ligar

yoursiteUrl / rest / session / token

para obter token

$http({
            method: 'GET',
            url: 'siteUrl/api/user/getInfo?_format=json',
                          withCredentials:true,
                          headers: {
                                   'Content-Type': "application/hal+json",
                                   'X-CSRF-Token': token,
                                   'Authorization': 'Basic ' + btoa(user+':'+password),

                         },


                        }).then(function successCallback(response) {

                             return response;

                          }, function errorCallback(response) {
                              return false;

                          });

Após a resposta de @ tyler.frankenstein, se você deseja implementar um formulário de login com o Ajax, pode, por exemplo, usar o jQuery.

1. Obtenha um token CSRF

Precisamos fazer uma solicitação POST para o user/loginterminal da API do Drupal 8. Esse ponto de extremidade (considerado como "método não seguro") exige que você envie um token CSRF.

A primeira etapa é obter esse token enviando uma solicitação AJAX para o rest/session/tokenterminal:

var getCsrfToken = function(callback) {
    $.get(Drupal.url('rest/session/token'))
        .done(function (data) {
            var csrfToken = data;
            callback(csrfToken);
        });
}

NB:

• O callbackparâmetro é uma função de retorno de chamada que será chamada quando o token CSRF for buscado
• Usamos a Drupal.urlfunção para obter o URL base do site

Este token deve ser enviado com um X-CSRF-Tokencabeçalho.

2. Login

Considere o seguinte HTML:

<form id="login" method="post" action="" accept-charset="UTF-8">
    <div class="input-field">
        <input id="edit-name" name="name" type="text" class="validate">
        <label for="edit-name">Username or email address</label>
    </div>
    <div class="input-field">
        <input id="edit-pass" name="pass" type="password" class="validate">
        <label for="edit-pass">Password</label>
    </div>
    <p><a href="{{ url('user.pass') }}">Forgot your password?</a></p>
    <button type="submit" class="btn btn-default btn-submit">Sign in</button>
</form>

... e o código jQuery correspondente:

$('form#login').on('submit', function(e) {
    e.preventDefault();

    var inputUsername = $('#edit-name').val();
    var inputPassword = $('#edit-pass').val();

    if (inputUsername != '' && inputPassword != '') {
        getCsrfToken(function(csrfToken) {
            $.ajax({
                url: Drupal.url('user/login?_format=json'),
                type: 'POST',
                dataType: 'json',
                data: JSON.stringify({name: inputUsername, pass: inputPassword}),
                headers: {
                    'X-CSRF-Token': csrfToken
                },
            }).done(function(response) {
                if (response.current_user) {
                    console.log('The user is logged!');
                }
            }).fail(function(jqXHR, textStatus) {
                ...
            });
        });
    }
});

Este código foi testado com sucesso com o Drupal 8.3.

Eu espero que isso te ajude!

Sim, claro, criei um blog sobre como testá-lo com o carteiro , e também outro sobre como configurar seu site drupal .

Neste projeto , fiz um login no Drupal com angular, usando o módulo Simple OAuth para o token.