API:Creación de cuentas
| Esta página es parte de la documentación de la API de acciones de MediaWiki. |
| Versión de MediaWiki: | ≥ 1.27 |
Esta página documenta la API de creación de cuenta a partir de MediaWiki 1.27. La documentación de la API tal como existía en versiones anteriores está disponible aquí: Api:Account creation/pre-1.27.
Documentación de API
Crear una cuenta
El proceso tiene tres pasos generales:
- Obtén los campos de API:Authmanagerinfo y el token de API:Tokens.
- Envías una solicitud POST con el token obtenido, información de usuario y otros campos, y devuelve URL a la API.
- Trata la respuesta, lo que podría implicar más solicitudes POST para proporcionar más información.
Ejemplo 1: Procesar en un wiki sin extensiones especiales de autenticación
Un wiki sin extensiones de autentificación especial puede ser bastante sincero. Si tu código sabe qué campos se requerirán, podría omitir la llamada a API:Authmanagerinfo y solo asumir qué campos serán necesarios (es decir nombre de usuario, contraseña y contraseña reescrita, correo electrónico, posiblemente nombre real).
Si estás creando una cuenta alguien más, necesitarás especificar una razón para la misma al incluir un parámetro
reason en la solicitud POST. También podías usar mailpassword en lugar de los parámetros password y retype, para hacer que MediaWiki envíe al nuevo usuario una contraseña temporal por correo electrónico.
Solicitud POST
Respuesta
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
Código de ejemplo
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 );
} );
} );
Ejemplo 2: Proceso en un wiki con una extensión CAPTCHA
Observe el primer paso abajo podría, si prefieres, realizarse en dos pasos: uno para obtener los campos disponibles desde API:Authmanagerinfo y otro para obtener el token desde API:Tokens.
<span id="First_step:_Fetch_fields_available_from_API:Authmanagerinfo_and_token_from_API:Tokens">
Primer paso: obtener campos disponibles desde API:Authmanagerinfo y token desde API:Tokens
api.php?
| Resultado |
|---|
{
"batchcomplete": "",
"query": {
"authmanagerinfo": {
"canauthenticatenow": "",
"cancreateaccounts": "",
"preservedusername": "",
"requests": [
{
"id": "CaptchaAuthenticationRequest",
"metadata": {
"type": "image",
"mime": "image/png"
},
"required": "required",
"provider": "CaptchaAuthenticationRequest",
"account": "CaptchaAuthenticationRequest",
"fields": {
"captchaId": {
"type": "hidden",
"value": "16649214",
"label": "CAPTCHA ID",
"help": "This value should be sent back unchanged."
},
"captchaInfo": {
"type": "null",
"value": "/w/index.php?title=Special:Captcha/image&wpCaptchaId=16649214",
"label": "To help protect against automated account creation, please enter the words that appear below in the box ([[Special:Captcha/help|more info]]):",
"help": "Description of the CAPTCHA."
},
"captchaWord": {
"type": "string",
"label": "CAPTCHA",
"help": "Solution of the CAPTCHA."
}
}
}
...
]
},
"tokens": {
"createaccounttoken": "1de8d3f8023305742e69db9e16b4d5365bd82f9c+\\"
}
}
}
|
Segundo paso: envía una solicitud de publicación junto con un token de creación de cuenta, información de usuario y URL de retorno
api.php?
| Resultado |
|---|
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
|
Código de ejemplo
Nota que este ejemplo de código separa las solicitudes API:Authmanagerinfo y API:Tokens, y generalmente asume que habrá un CAPTCHA y ninguna otra complicación.
| create_account_with_captcha.py |
|---|
#!/usr/bin/python3
"""
create_account_with_captcha.py
MediaWiki Action API Code Samples
Demo of `createaccount` module: Create an account on a wiki with a special
authentication extension installed. This example considers a case of a wiki
where captcha is enabled through extensions like ConfirmEdit
(https://www.mediawiki.org/wiki/Extension:ConfirmEdit)
MIT license
"""
import requests
from flask import Flask, render_template, flash, request
S = requests.Session()
WIKI_URL = "https://test.wikipedia.org"
API_ENDPOINT = WIKI_URL + "/w/api.php"
# App config.
DEBUG = True
APP = Flask(__name__)
APP.config.from_object(__name__)
APP.config['SECRET_KEY'] = 'enter_your_secret_key'
@APP.route("/", methods=['GET', 'POST'])
def show_form():
""" Render form template and handle form submission request """
fields = get_form_fields()
captcha = fields['CaptchaAuthenticationRequest']
captcha_url = WIKI_URL + captcha['captchaInfo']['value']
captcha_id = captcha['captchaId']['value']
display_fields = []
user_fields = []
captcha_fields = []
for field in fields:
for name in fields[field]:
details = {
'name': name,
'type': fields[field][name]['type'],
'label': fields[field][name]['label']
}
if field != "CaptchaAuthenticationRequest":
user_fields.append(details)
else:
if name == 'captchaWord':
captcha_fields.append(details)
display_fields = user_fields + captcha_fields
if request.method == 'POST':
create_account(request.form, captcha_id)
return render_template('create_account_form.html', \
captcha=captcha_url, fields=display_fields)
def get_form_fields():
""" Fetch the form fields from `authmanagerinfo` module """
result = {}
response = S.get(url=API_ENDPOINT, params={
'action': 'query',
'meta': 'authmanagerinfo',
'amirequestsfor': 'create',
'format': 'json'
})
data = response.json()
query = data and data['query']
authmanagerinfo = query and query['authmanagerinfo']
fields = authmanagerinfo and authmanagerinfo['requests']
for field in fields:
if field['id'] in ('MediaWiki\\Auth\\UserDataAuthenticationRequest', \
'CaptchaAuthenticationRequest', 'MediaWiki\\Auth\\PasswordAuthenticationRequest'):
result[field['id']] = field['fields']
return result
def create_account(form, captcha_id):
""" Send a post request along with create account token, user information
and return URL to the API to create an account on a wiki """
createtoken = fetch_create_token()
response = S.post(url=API_ENDPOINT, data={
'action': 'createaccount',
'createtoken': createtoken,
'username': form['username'],
'password': form['password'],
'retype': form['retype'],
'email': form['email'],
'createreturnurl': 'http://127.0.0.1:5000/',
'captchaId': captcha_id,
'captchaWord': form['captchaWord'],
'format': 'json'
})
data = response.json()
createaccount = data['createaccount']
if createaccount['status'] == "PASS":
flash('Success! An account with username ' + \
form['username'] + ' has been created!')
else:
flash('Oops! Something went wrong -- ' + \
createaccount['messagecode'] + "." + createaccount['message'])
def fetch_create_token():
""" Fetch create account token via `tokens` module """
response = S.get(url=API_ENDPOINT, params={
'action': 'query',
'meta': 'tokens',
'type': 'createaccount',
'format': 'json'
})
data = response.json()
return data['query']['tokens']['createaccounttoken']
if __name__ == "__main__":
APP.run()
|
| create_account_form.html |
|---|
<!DOCTYPE html>
<title>MediaWiki Create Account</title>
<!-- CSS files are in here: https://github.com/srish/MediaWiki-Action-API-Code-Samples/tree/master/static -->
<link rel="stylesheet" href="static/bootstrap/css/bootstrap.min.css">
<link rel="stylesheet" href="static/css/account_form.css">
<div class="container">
<h2>Create MediaWiki Account</h2>
<form method="POST">
<div class="form-group">
<div class="form-field">
<div class="label-field">Enter your username</div>
<input name="username">
</div>
<div class="form-field">
<div class="label-field">Password</div>
<input type="password" name="password">
</div>
<div class="form-field">
<div class="label-field">Confirm password</div>
<input type="password" name="confirm-password">
</div>
<div class="form-field">
<div class="label-field">Enter address (optional)</div>
<input name="email">
</div>
<div class="form-field">
<div class="label-field">Enter the text you see on the image below</div>
<input name="captcha-word">
</div>
<img src="{{ captcha }}">
</div>
<button type="submit" class="btn btn-success">Create your account</button>
</form>
<br>
{% with messages = get_flashed_messages(with_categories=true) %}
{% if messages %}
{% for message in messages %}
<div class="alert alert-info">
{{ message[1] }}
</div>
{% endfor %}
{% endif %}
{% endwith %}
</div>
<br>
</div>
</div>
|
Ejemplo 3: Creación de cuenta en un wiki con un CAPTCHA, una extensión OpenID y una extensión de autenticación de dos factores habilitada
<span id="First_step:_Fetch_fields_available_from_API:Authmanagerinfo_and_token_from_API:Tokens">
Primer paso: obtener campos disponibles desde API:Authmanagerinfo y token desde API:Tokens
La obtención de API:Authmanagerinfo y API:Tokens es en gran medida la misma que en el ejemplo anterior, por lo que no se repite aquí. La lista de solicitudes devueltas por API:Authmanagerinfo incluirá definiciones tanto para la extensión CAPTCHA como para la extensión OpenID.
Segundo paso: Responde el CAPTCHA y selecciona la autenticación OpenID.
api.php?
| Resultado |
|---|
{
"createaccount": {
"status": "REDIRECT",
"redirecttarget": "https://openid.example.net/openid-auth.php?scope=openid&response_type=code&client_id=ABC&redirect_uri=https://wiki.example.org/wiki/Special:OpenIDConnectReturn&state=XYZ123",
"requests": [
{
"id": "OpenIdConnectResponseAuthenticationRequest",
"metadata": {},
"required": "required",
"provider": "OpenID Connect at example.net",
"account": "",
"fields": {
"code": {
"type": "string",
"label": "OpenID Code",
"help": "OpenID Connect code response"
},
"state": {
"type": "string",
"label": "OpenID State",
"help": "OpenID Connect state response"
},
}
}
]
}
}
|
El cliente estaría esperando para redirigir el navegador del usuario al proporcionado redirecttarget
El proveedor de OpenID autenticaría y redirigiría a Special: OpenIDConnectReturn en el wiki, que validaría la respuesta de OpenID y luego redirigiría al createreturnurl proporcionado en el primer POST a la API con los parámetros código y estado agregados.
El cliente recupera el control del proceso de retorno en este punto y realiza su próxima solicitud API.
Tercer paso: volver desde OpenID.
El cliente publica el código y estado de vuelta al API. La respuesta de la API tiene la extensión de autenticación de dos factores, provocando al usuario a instalar su segundo factor.
api.php?
| Resultado |
|---|
{
"createaccount": {
"status": "UI",
"message": "Set up two-factor authentication",
"requests": [
{
"id": "TwoFactorAuthenticationRequest",
"metadata": {
"account": "Alice",
"secret": "6CO3 2AKV EP2X MIV5"
},
"required": "optional",
"provider": "",
"account": "",
"fields": {
"2FAInfo": {
"type": "null",
"label": "A bunch of text describing how to set up two-factor auth.",
"help": "Two-factor authentication setup instructions"
},
"code": {
"type": "string",
"label": "Code",
"help": "Two-factor authentication code"
}
}
},
{
"id": "MediaWiki\\Auth\\ButtonAuthenticationRequest:skip2FASetup",
"metadata": {},
"required": "optional",
"provider": "MediaWiki\\Auth\\ButtonAuthenticationRequest",
"account": "MediaWiki\\Auth\\ButtonAuthenticationRequest:skip2FASetup",
"fields": {
"skip2FASetup": {
"type": "button",
"label": "Skip",
"help": "Skip two-factor authentication setup"
}
}
}
]
}
}
|
Ahora el cliente incitaría al usuario a configurar una nueva cuenta en su aplicación de autenticación de dos factores e ingresar el código actual, o permitir al usuario omitir la instalación 2FA. Supongamos que el usuario instala 2FA
Cuarto paso: instalar la autenticación de dos factores.
api.php?
| Resultado |
|---|
{
"createaccount": {
"status": "PASS",
"username": "Alice"
}
}
|
La creación de la cuenta finalmente ha tenido éxito.
Si en algún punto la creación de la cuenta falla, se devolverá una respuesta con el estado FAIL, junto con un message para mostrar al usuario.
Errores posibles
| Código | Información |
|---|---|
| badtoken | Token cuenta de creación no válido |
| notoken | Se debe establecer el parámetro token. |
| mustpostparams | Se encontró el siguiente parámetro en la cadena de la consulta, pero deben estar en el cuerpo del POST: createtoken. |
| missingparam | Al menos uno de los parámetros "createcontinue" y "createreturnurl" es necesario. |
| authmanager-create-no-primary | Las credenciales suministradas no pueden usarse para la creación de la cuenta. |
| noemailcreate | Necesitas proporcionar una dirección de correo electrónico válida. |
| invalidemailaddress | No se puede aceptar la dirección de correo electrónico, pues parece que tiene un formato no válido.
Por favor, escribe una dirección bien formada o deja el campo en blanco. |
| badretype | Las contraseñas no coinciden. |
| userexists | El nombre de usuario indicado ya está en uso.
Elige un nombre diferente. |
| captcha-createaccount-fail | Falta el código CAPTCHA, o éste es incorrecto. |
| acct_creation_throttle_hit | Los visitantes a esta wiki que utilizaron su dirección IP han creado num cuentas en las últimas 24 horas, lo cual es el máximo permitido en ese período de tiempo.
Como resultado, los visitantes que utilicen esa dirección IP no pueden crear más cuentas de usuario en este momento. Si estás en un evento cuyo objeto es contribuir a los proyectos Wikimedia, por favor visite esta página para resolver el problema. |
Documentos adicionales
- La creación de cuentas se registra en Special:log/newusers.
Si has iniciado sesión, tu nombre de usuario también se registrará al crear una cuenta.
- Mientras ejecutas los fragmentos de código proporcionados en esta página, recuerda:
- Una vez que se crea una cuenta en un wiki, no puede ser eliminada.
- Utiliza siempre [https://test.wikipedia.org
https://test.wikipedia.org/w/api.php] como punto final, para que no crees accidentalmente cuentas en producción wikis
- MediaWiki administradores web y desarrolladores de extension pueden deshabilitar esta característica API insertando la siguiente línea en el archivo de configuración:
$wgAPIModules['createaccount'] = 'ApiDisabled';