Quelqu'un at-il un qui fonctionne REST Se connecter sur Drupal 8?
Voilà ce que j'ai essayé.
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
Il me renvoie HTML au lieu de JSON .
À partir de 8.2, Drupal prend en charge les points de terminaison json pour l'authentification par cookie. Vous n'avez plus besoin de poster le formulaire ????
curl --header "Content-type: application/json" --request POST \
--data '{"name":"admin", "pass":"admin"}' \
http://drupal.d8/user/login?_format=json
La sortie ressemblera
{"current_user":{"uid":"1","roles":["authenticated","administrator"],"name":"admin"},"csrf_token":"wBr9ldleaUhmP4CgVh7PiyyxgNn_ig8GgAan9-Ul3Lg","logout_token":"tEulBvihW1SUkrnbCERWmK2jr1JEN_mRAQIdNNhhIDc"}
Modifier l'enregistrement: https://www.drupal.org/node/2720655
Autres méthodes d'authentification: https://www.drupal.org/docs/8/core/modules/rest/using-other-authentication-protocols
Voici comment vous pouvez vous connecter via JavaScript pour Drupal 8 REST:
Drupal 8.2 et au-delà
http://example.com/user/login?_format=json
application/json
{ "name": "admin", "pass": "myPassword" }
200 OK
Cela se connectera correctement via l'authentification par cookie et retournera un résultat similaire à celui-ci:
{
"current_user": {
"uid":"1",
"roles":["authenticated"],
"name":"admin"
},
"csrf_token":"abc123",
"logout_token":"def456"
}
J'ai créé un module contrib appelé jDrupal qui facilite la connexion avec JavaScript (entre autres):
// Login and show the user their id.
jDrupal.userLogin('admin', 'myPassword').then(function() {
alert(jDrupal.currentUser().id());
});
Avant Drupal 8.2
http://example.com/user/login
application/x-www-form-urlencoded
name=admin&pass=myPassword&form_id=user_login_form
200 OK | 303 See Other
Vous enverrez les données dans l'URL sous forme de chaîne de requête. Le résultat sera HTML, donc il ne vous renverra rien d'utile, mais il se connectera correctement via l'authentification par cookie.
L'authentification RESTful signifie d'envoyer une authentification à chaque demande car elle est sans état. L'exemple fourni par Drupal 8 core est le module Basic Auth, qui permet d'envoyer des informations d'authentification pour une demande HTTP via l'authentification HTTP de base à un utilisateur autorisé à accéder au contenu via GET.
Curl: 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
Cependant, ce n'est généralement pas suffisant. Les modules de contribution simple_oauth et oauth fournissent respectivement le support OAuth 2 et 1), avec lequel une requête HTTP peut être effectuée avec OAuth jetons d'authentification basés sur les flux de travail OAuth décrits dans ces modules).
Mais la vraie question semble être
Il n'y a pas de module Drupal 8 stable pour le faire, mais le module Services fournit des méthodes pour créer des actions non RESTful et des actions ciblées telles que "login").
Ce qui suit fonctionne après avoir configuré un point de terminaison appelé "api":
Curl: 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"}
Cela renvoie l'ID et le nom de la session JSON (également définis dans l'en-tête Set-Cookie de la réponse).
et vous pouvez également vous connecter avec l'appel ajax Jquery avec l'extrait suivant
$.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
}
});
Version Drupal Core: 8.x-4.x
Vous devez d'abord activer le service de connexion utilisateur, cela peut être accompli de nombreuses manières, je préfère utiliser le module REST UI .
Allez dans /admin/config/services/rest et activez Utilisateur Reste Ressource.
Une fois activé, vous pouvez aller dans /admin/config/services/rest/resource/entity% 3Auser/edit en cliquant sur Modifier à côté de la ressource utilisateur . Assurez-vous d'activer la méthode [~ # ~] get [~ # ~] .
Maintenant que vous avez tout configuré, vous pouvez commencer à utiliser le service en exécutant cette commande dans le terminal ou en utilisant n'importe quelle application pour les requêtes curl comme: Postman et Restlet clients.
[~ # ~] note [~ # ~] : le jeton CSRF peut être obtenu à partir de: /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'
Les objets de retour sont les suivants:
[~ # ~] succès [~ # ~]:
{
"current_user": {
"uid": "1",
"roles": [
"authenticated"
],
"name": "Admin"
},
"csrf_token": "bbbbbbbbbbbbbbbbbbbbbbbbbb",
"logout_token": "ccccccccccccccccccccccccc"
}
[~ # ~] échec [~ # ~]:
{
"message":"Sorry, unrecognized username or password."
}
Suite à la réponse de @ tyler.frankenstein, si vous souhaitez implémenter un formulaire de connexion avec Ajax, vous pouvez par exemple utiliser jQuery.
Nous devons faire une demande POST au user/login
noeud final de l'API Drupal 8. Ce noeud final (considéré comme une "méthode non sûre") nécessite que vous envoyiez un jeton CSRF.
La première étape consiste à obtenir ce jeton en envoyant une demande AJAX au rest/session/token
point final:
var getCsrfToken = function(callback) {
$.get(Drupal.url('rest/session/token'))
.done(function (data) {
var csrfToken = data;
callback(csrfToken);
});
}
N.B .:
callback
est une fonction de rappel qui sera appelée lorsque le jeton CSRF sera récupéréDrupal.url
fonction pour obtenir l'URL de base du siteCe jeton doit être envoyé avec un X-CSRF-Token
entête.
Considérez le code HTML suivant:
<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>
... et le code jQuery correspondant:
$('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) {
...
});
});
}
});
Ce code a été testé avec succès avec Drupal 8.3.
J'espère que cela t'aidera!
J'utilise une connexion RESTFul personnalisée sur drupal 8 mais pas avec un cookie. C'est pour une application mobile et chaque fois que j'ai besoin d'informations, j'utilise un simple Authenticate:
Depuis Drupal 8.2x nous avons besoin de 2 fichiers dans un module:
rest.ressource.user.rest_ressource.yml dans le dossier 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
Vous pouvez ajouter plus de méthode comme DELETE/POST
Ensuite, nous avons besoin du fichier
userRestRessource.php dans 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'oubliez pas d'aller au droit d'utilisateur pour accepter la méthode GET/POST ou tout ce que vous avez ajouté dans votre configuration.
Avec cela, vous pouvez créer chaque fichier REST personnalisé pour chaque entité personnalisée.
Et dans mon js: N'oubliez pas d'appeler
yoursiteUrl/rest/session/token
pour obtenir un jeton
$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;
});
Oui, bien sûr, j'ai fait un blog sur la façon de le tester avec postman , et aussi un autre sur la façon de configurer votre site drupal .
Dans ce projet j'ai fait une connexion pour Drupal avec angular, en utilisant le module Simple OAuth pour le token).