API:Création de compte

From MediaWiki.org
Jump to navigation Jump to search
This page is a translated version of the page API:Account creation and the translation is 100% complete.
Other languages:
Deutsch • ‎English • ‎Türkçe • ‎dansk • ‎español • ‎français • ‎italiano • ‎polski • ‎português • ‎română • ‎русский • ‎العربية • ‎ไทย • ‎中文 • ‎日本語 • ‎한국어
Version de MediaWiki : 1.27
Cette page documente l'API de création de compte de MediaWiki 1.27. La documentation de l'API telle qu'elle existait dans les versions précédentes est disponible ici: Api:Account creation/pre-1.27 .

Documentation de l'API


action=createaccount (create)

(main | createaccount)
  • This module requires write rights.
  • This module only accepts POST requests.
  • Source: MediaWiki
  • License: GPL-2.0-or-later

Create a new user account.

The general procedure to use this module is:

  1. Fetch the fields available from action=query&meta=authmanagerinfo with amirequestsfor=create, and a createaccount token from action=query&meta=tokens.
  2. Present the fields to the user, and obtain their submission.
  3. Post to this module, supplying createreturnurl and any relevant fields.
  4. Check the status in the response.
    • If you received PASS or FAIL, you're done. The operation either succeeded or it didn't.
    • If you received UI, present the new fields to the user and obtain their submission. Then post to this module with createcontinue and the relevant fields set, and repeat step 4.
    • If you received REDIRECT, direct the user to the redirecttarget and wait for the return to createreturnurl. Then post to this module with createcontinue and any fields passed to the return URL, and repeat step 4.
    • If you received RESTART, that means the authentication worked but we don't have a linked user account. You might treat this as UI or as FAIL.
Parameters:
createrequests

Only use these authentication requests, by the id returned from action=query&meta=authmanagerinfo with amirequestsfor=create or from a previous response from this module.

Separate values with | or alternative. Maximum number of values is 50 (500 for bots).
createmessageformat

Format to use for returning messages.

One of the following values: html, wikitext, raw, none
Default: wikitext
createmergerequestfields

Merge field information for all authentication requests into one array.

Type: boolean (details)
createpreservestate

Preserve state from a previous failed login attempt, if possible.

If action=query&meta=authmanagerinfo returned true for hasprimarypreservedstate, requests marked as primary-required should be omitted. If it returned a non-empty value for preservedusername, that username must be used for the username parameter.

Type: boolean (details)
createreturnurl

Return URL for third-party authentication flows, must be absolute. Either this or createcontinue is required.

Upon receiving a REDIRECT response, you will typically open a browser or web view to the specified redirecttarget URL for a third-party authentication flow. When that completes, the third party will send the browser or web view to this URL. You should extract any query or POST parameters from the URL and pass them as a createcontinue request to this API module.

createcontinue

This request is a continuation after an earlier UI or REDIRECT response. Either this or createreturnurl is required.

Type: boolean (details)
createtoken

A "createaccount" token retrieved from action=query&meta=tokens

This parameter is required.
*
This module accepts additional parameters depending on the available authentication requests. Use action=query&meta=authmanagerinfo with amirequestsfor=create (or a previous response from this module, if applicable) to determine the requests available and the fields that they use.

Création d'un compte

Le processus possède trois étapes générales :

  1. Récupérez les champs de API:Authmanagerinfo et le jeton de API:Tokens/fr .
  2. Envoyez une requête POST avec le jeton récupéré, les informations utilisateur et les autres champs, et l'URL de retour de l'API.
  3. Gérez la réponse, qui peut impliquer d'autres requêtes POST pour fournir davantage d'informations.

Exemple 1: Traitement sur un wiki sans extensions d'authentification particulières

Un wiki sans extensions d'authentification spéciales peut être plutôt simple à traiter. Si votre code sait quels sont les champs qui seront obligatoires, il peut sauter l'appel à API:Authmanagerinfo et simplement supposer les champs nécessaires (par exemple le nom de l'utilisateur, le mot de passe & le mot de passe retapé, l'adresse de courriel, éventuellement le nom réel).

Si vous créez un compte pour une autre personne, vous devrez spécifier un motif pour le même en incluant un paramètre reason dans la requête POST. Vous pouvez aussi utiliser mailpassword à la place des paramètres password et retype pour que MediaWiki envoie au nouvel utilisateur un mot de passe temporaire par courriel.

Requête POST

Réponse

{
    "createaccount": {
        "status": "PASS",
        "username": "Zane"
    }
}

Exemple de code

Python

#!/usr/bin/python3

"""
    create_account.py

    MediaWiki API Demos
    Demo of `createaccount` module: Create an account on a wiki without the
    special authentication extensions

    MIT license
"""

import requests

S = requests.Session()

WIKI_URL = "http://dev.wiki.local.wmftest.net:8080"
API_ENDPOINT = WIKI_URL + "/w/api.php"

# First step
# Retrieve account creation token from `tokens` module

PARAMS_0 = {
    'action':"query",
    'meta':"tokens",
    'type':"createaccount",
    'format':"json"
}

R = S.get(url=API_ENDPOINT, params=PARAMS_0)
DATA = R.json()

TOKEN = DATA['query']['tokens']['createaccounttoken']

# Second step
# Send a post request with the fetched token and other data (user information,
# return URL, etc.)  to the API to create an account

PARAMS_1 = {
    'action': "createaccount",
    'createtoken': TOKEN,
    'username': 'your_username',
    'password': 'your_password',
    'retype': 'retype_your_password',
    'createreturnurl': WIKI_URL,
    'format': "json"
}

R = S.post(API_ENDPOINT, data=PARAMS_1)
DATA = R.json()

print(DATA)

PHP

<?php

/*
    create_account.php

    MediaWiki API Demos
    Demo of `createaccount` module: Create an account on a wiki without the
    special authentication extensions
    MIT license
*/

$wikiUrl = "http://dev.wiki.local.wmftest.net:8080";
$endPoint = $wikiUrl . "/w/api.php";

$createAccount_Token = getCreateAccountToken(); // Step 1
createAccount( $createAccount_Token ); // Step 2

// Step 1: GET request to fetch createaccount token
function getCreateAccountToken() {
	global $endPoint;

	$params1 = [
		"action" => "query",
		"meta" => "tokens",
		"type" => "createaccount",
		"format" => "json"
	];

	$url = $endPoint . "?" . http_build_query( $params1 );

	$ch = curl_init( $url );
	curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
	curl_setopt( $ch, CURLOPT_COOKIEJAR, "cookie.txt" );
	curl_setopt( $ch, CURLOPT_COOKIEFILE, "cookie.txt" );

	$output = curl_exec( $ch );
	curl_close( $ch );

	$result = json_decode( $output, true );
	return $result["query"]["tokens"]["createaccounttoken"];
}

// Step 2: POST request with the fetched token and other data (user information,
// return URL, etc.)  to the API to create an account
function createAccount( $createAccount_Token ) {
	global $endPoint, $wikiUrl;

	$params2 = [
		"action" => "createaccount",
		"createtoken" => $createAccount_Token,
		"username" => "your_username",
		"password" => "your_password",
		"retype" => "retype_your_password",
		"createreturnurl" => $wikiUrl,
		"format" => "json"
	];

	$ch = curl_init();

	curl_setopt( $ch, CURLOPT_URL, $endPoint );
	curl_setopt( $ch, CURLOPT_POST, true );
	curl_setopt( $ch, CURLOPT_POSTFIELDS, http_build_query( $params2 ) );
	curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
	curl_setopt( $ch, CURLOPT_COOKIEJAR, "cookie.txt" );
	curl_setopt( $ch, CURLOPT_COOKIEFILE, "cookie.txt" );

	$output = curl_exec( $ch );
	curl_close( $ch );

	echo( $output );
}

JavaScript

/*  
    create_account.js
 
    MediaWiki API Demos
    Demo of `createaccount` module: Create an account on a wiki without the
    special authentication extensions

    MIT license
*/

var request = require('request').defaults({jar: true}),
    wikiUrl = "http://dev.wiki.local.wmftest.net:8080",
    endPoint = wikiUrl + "/w/api.php";

// Step 1: GET request to fetch createaccount token
function getCreateAccountToken() {
    var params_0 = {
        action: "query",
        meta: "tokens",
        type: "createaccount",
        format: "json"
    };

    request.get({ url: endPoint, qs: params_0 }, function (error, res, body) {
        if (error) {
            return;
        }
        var data = JSON.parse(body);
        createaccount(data.query.tokens.createaccounttoken);
    });
}

// Step 2: POST request with the fetched token and other data (user information,
// return URL, etc.)  to the API to create an account
function createaccount(createaccount_token) {
    var params_1 = {
        action: "createaccount",
        username: "your_username",
        password: "your_password",
        retype: "retype_your_password",
        createreturnurl: wikiUrl,
        createtoken: createaccount_token,
        format: "json"
    };

    request.post({ url: endPoint, form: params_1 }, function (error, res, body) {
        if (error) {
            return;
        }
        console.log(body);
    });
}

// Start From Step 1
getCreateAccountToken();

MediaWiki JS

/*
	create_account.js

	MediaWiki API Demos
    Demo of `createaccount` module: Create an account on a wiki without the
    special authentication extensions

	MIT License
*/

var params = {
		action: 'query',
		meta: 'tokens',
		type: 'createaccount',
		format: 'json'
	},
	api = new mw.Api();

api.get( params ).done( function ( data ) {
	var token = data.query.tokens.createaccounttoken,
		params1 = {
			action: 'createaccount',
			username: 'your_username',
			password: 'your_password',
			retype: 'retype_your_password',
			createreturnurl: 'http:' + mw.config.get( 'wgServer' ),
			createtoken: token,
			format: 'json'
		};

	api.post( params1 ).done( function ( data ) {
		console.log( data );
	} );
} );

Exemple 2: Traitement sur un wiki avec une extension CAPTCHA

Remarquez que la première étape ci-dessous pourrait, si vous le voulez, être faite en deux parties: la première pour récupérer les champs disponibles de API:Authmanagerinfo et la seconde pour récupérer le jeton de API:Tokens/fr .

Première étape: récupérer les champs disponibles de API:Authmanagerinfo et le jeton de API:Tokens/fr

Seconde étape: envoyer une requête Post avec un jeton de création de compte, les informations utilisateur et l'URL de retour

Exemple de code

Notez que ce morceau de code sépare les requêtes API:Authmanagerinfo et API:Tokens/fr , et suppose généralement qu'il y aura un CAPTCHA et pas d'autres complications.

Exemple 3: création de compte sur un wiki avec un CAPTCHA, une extension OpenID, et une extension d'authentification à deux facteurs activée

Première étape: récupérer les champs disponibles de API:Authmanagerinfo et le jeton de API:Tokens/fr

La récupération de API:Authmanagerinfo et API:Tokens/fr est très similaire à l'exemple précédent, cela n'est donc pas répété ici. La liste des requêtes retournées par API:Authmanagerinfo va contenir en même temps les définitions pour l'extension CAPTCHA et l'extension OpenID.

Seconde étape : répondre au CAPTCHA et sélectionner l'authentification OpenID.

Le navigateur de l'utilisateur va alors être redirigé vers le redirecttarget fourni.

Ensuite, l'authentification par OpenID va s'effectuer, avant de rediriger vers Special:OpenIDConnectReturn sur le wiki, qui validera la réponse de OpenID et renverra l'utilisateur vers le createreturnurl renseigné dans la première requête POST vers l'API, avec les paramètres code et state ajoutés.

L'utilisateur reprend alors le contrôle du processus à ce point et effectue la requête suivante vers l'API.

Troisième étape : après l'authentification par OpenID.

Le cient met code et state qu'il renvoie à l'API. La réponse de l'API comporte l'extension de l'authentification à deux facteurs qui demande à l'utilisateur de définir son second facteur.

Maintenant le client va demander à l'utilisateur de définir un nouveau compte dans son application à authentification à deux facteurs et entrer le code actuel, ou bien autoriser l'utilisateur à sauter l'authentification à deux facteurs. Faisons comme si l'utilisateur effectuait cette authentification à deux facteurs.

Quatrième étape : choisir l'authentification à deux facteurs.

La création du compte a finalement réussi.

Si la création du compte échoue à un moment quelconque, une réponse avec un statut FAIL sera retournée, au côté d'un message qui s'affichera chez l'utilisateur.

Erreurs possibles

Code Infos
badtoken Jeton non valide de création de compte
notoken Le paramètre token doit être défini.
mustpostparams Le paramètre suivant a été trouvé dans la chaîne de requête, mais doit être dans le corps du POST : createtoken.
missingparam Au moins un des paramètres "createcontinue" et "createreturnurl" est obligatoire.
authmanager-create-no-primary Les informations d’identification fournies n’ont pas pu être utilisées pour la création de compte.
invalidemailaddress Cette adresse courriel ne peut pas être acceptée car son format paraît incorrect.

Entrez une adresse correctement formatée ou laissez ce champ vide.

badretype Les mots de passe que vous avez saisis ne correspondent pas.
userexists Le nom d’utilisateur saisi est déjà utilisé.

Veuillez choisir un nom différent.

captcha-createaccount-fail CAPTCHA erroné ou manquant.
acct_creation_throttle_hit Les visiteurs de ce wiki utilisant votre adresse IP ont créé 1 compte ce dernier jour, ce qui est le maximum autorisé pour cette période de temps. Par conséquent, les visiteurs utilisant cette adresse IP ne peuvent plus créer de compte pour l’instant.

Si vous participez à un événement qui a pour but de contribuer aux projets de Wikimédia, veuillez voir Demander la levée temporaire de la limitation IP pour aider à résoudre ce problème.

Notes additionnelles

Si vous êtes connecté, votre nom d'utilisateur sera également enregistré si vous créez un compte.

  • Quand vous excutez les parties de code fournies sur cette page, rappelez-vous que :
    • Une fois qu'un compte est créé sur un wiki, il ne peut pas être supprimé.
    • Utilisez toujours https://test.wikipedia.org/w/api.php comme point de terminaison, pour ne pas créer accidentellement de comptes sur les wikis de production.
  • Les administrateurs de site MediaWiki et les développeurs d'extensions peuvent désactiver ces fonctionalités de l'API en insérant la ligne suivante dans le fichier de configuration :
$wgAPIModules['createaccount'] = 'ApiDisabled';

Voir aussi