API:Creación de cuentas

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ă • ‎русский • ‎العربية • ‎ไทย • ‎中文 • ‎日本語 • ‎한국어
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


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 clients allowed higher limits).
createmessageformat

Format to use for returning messages.

One of the following values: html, none, raw, wikitext
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.

Crear una cuenta

El proceso tiene tres pasos generales:

  1. Obtén los campos de API:Authmanagerinfo y el token de API:Tokens .
  2. Envías una solicitud POST con el token obtenido, información de usuario y otros campos, y devuelve URL a la API.
  3. 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 .

Primer paso: obtener campos disponibles desde API:Authmanagerinfo y token desde API:Tokens

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

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.

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

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.

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.

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.

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.
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 este 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

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:

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';

Véase también