API:Account creation/de
![]() | Diese Seite ist Teil der Dokumentation der MediaWiki action API. |
MediaWiki Version: | ≥ 1.27 |
API-Dokumentation
![]() | Die folgende Dokumentation ist die Ausgabe von Special: |
action=createaccount (create)
- 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:
- Fetch the fields available from action=query&meta=authmanagerinfo with amirequestsfor=create, and a createaccount token from action=query&meta=tokens.
- Present the fields to the user, and obtain their submission.
- Post to this module, supplying createreturnurl and any relevant fields.
- 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.
- 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 that are 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.
- Start the process of creating the user Example with the password ExamplePassword.
- api.php?action=createaccount&username=Example&password=ExamplePassword&retype=ExamplePassword&createreturnurl=http://example.org/&createtoken=123ABC [open in sandbox]
Erstellen eines Kontos
Der Prozess umfasst drei Schritte:
- Erhalte die Felder aus API:Authmanagerinfo und das Token aus API:Tokens .
- Sende eine POST-Abfrage mit dem erhaltenen Token, Benutzerinformation und anderen Feldern und gib die URL an die API.
- Gehe mit der Antwort um, was weitere POST-Abfragen beinhalten kann, um weitere Informationen zu erhalten.
Beispiel 1: Prozess für ein Wiki ohne spezielle Authentifizierungserweiterungen
Bei einem Wiki ohne spezielle Authentifizierungs-Erweiterungen kann der Prozess recht einfach sein. Wenn dein Code weiß, welche Felder erforderlich sind, wird die Abfrage an API:Authmanagerinfo möglicherweise übersprungen und nur angenommen, welche Felder benötigt werden (d.h. Benutzername, Passwort & Wiederholung des Passwortes, Email, eventuell Realname).
reason
-Parameter verwendest. Du kannst auch mailpassword
anstatt der Parameter password
und retype
nutzen, um durch MediaWiki ein temporäres Passwort per Email an den neuen Benutzer senden zu lassen.
POST-Anfrage
Antwort
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
Beispielcode
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 );
} );
} );
Beispiel 2: Prozess für ein Wiki mit einer CAPTCHA-Erweiterung
Beachte, dass der erste Schritt unten auch in zwei Schritten erfolgen kann: Einem zum Erhalt der Felder aus API:Authmanagerinfo und einem weiteren zum Erhalt des Tokens aus API:Tokens .
Erster Schritt: Felder aus API:Authmanagerinfo füllen und Token aus API:Tokens erhalten
Ergebnis |
---|
{
"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+\\"
}
}
}
|
Zweiter Schritt: Senden einer Post-Abfrage zusammen mit einem Kontoerstellungs-Token, Benutzerinformationen und URL-Ausgabe
Ergebnis |
---|
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
|
Beispielcode
Beachte, dass dieses Code-Beispiel die Abfragen API:Authmanagerinfo und API:Tokens trennt und allgemein annimmt, dass es ein CAPTCHA und keine anderen Komplikationen gibt.
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>
|
Beispiel 3: Benutzerkontenerstellung in einem Wiki mit CAPTCHA, OpenID-Erweiterung und aktivierter Zwei-Faktor-Authentifizierung
Erster Schritt: Felder aus API:Authmanagerinfo füllen und Token aus API:Tokens erhalten
Der Erhalt von API:Authmanagerinfo und API:Tokens erfolgt größtenteils so wie im vorherigen Beispiel und wird hier deshalb nicht wiederholt. Die von API:Authmanagerinfo ausgegebene Liste von Abfragen wird Definitionen für die CAPTCHA-Erweiterung und die OpenUD-Erweiterung enthalten.
Zweiter Schritt: ausfüllen der CAPTCHA und Auswahl von OpenID-Authentifikation
Ergebnis |
---|
{
"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"
},
}
}
]
}
}
|
Vom Client wird erwartet, den Browser des Benutzers zum bereitgestellten redirecttarget weiterzuleiten.
Der OpenID-Anbieter sollte authentifizieren und zu Special:OpenIDConnectReturn im Wiki weiterleiten, was die OpenID-Antwort validieren würde und dann weiterleiten zur createreturnurl, die im ersten POST an die API bereitgestellt wurde, mit angehängten code- und state-Parametern.
Der Client erhält an diesem Punkt die Kontrolle über den Prozess zurück und macht seine nächste API-Anfrage.
Dritter Schritt: Zurück von OpenID.
Der Client sendet code und state zurück zur API. Die API-Antwort enthält die Aufforderung der Zwei-Faktor-Authentifizierungs-Erweiterung an den Benutzer, den zweiten Faktor einzugeben.
Ergebnis |
---|
{
"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"
}
}
}
]
}
}
|
Der Client fordert jetzt den Benutzer dazu auf, in der App für die Zwei-Faktor-Authentifizierung ein neues Konto aufzusetzen und den aktuellen Code einzugeben oder erlaubt dem Benutzer, die 2FA-Einrichtung zu überspringen. Lass uns annehmen, dass der Benutzer 2FA aufsetzt.
Vierter Schritt: Zwei-Faktor-Authentifizierung aufsetzen.
Ergebnis |
---|
{
"createaccount": {
"status": "PASS",
"username": "Alice"
}
}
|
Die Kontenerstellung war erfolgreich.
Wenn die Kontenerstellung an irgendeinem Zeitpunkt scheitert, wird eine Antwort mit dem Status FAIL zurückgegeben und dem Benutzer wird eine message angezeigt.
Mögliche Fehler
Code | Information |
---|---|
badtoken | Ungültiges Token zur Kontenerstellung |
notoken | The token parameter must be set. |
mustpostparams | The following parameter was found in the query string, but must be in the POST body: createtoken. |
missingparam | At least one of the parameters "createcontinue" und "createreturnurl" is required. |
authmanager-create-no-primary | Die angegebenen Anmeldeinformationen konnten nicht für die Benutzerkontenerstellung verwendet werden. |
noemailcreate | Du musst eine gültige E-Mail-Adresse angeben. |
invalidemailaddress | Die E-Mail-Adresse wird nicht akzeptiert, weil sie ein ungültiges Format (eventuell ungültige Zeichen) zu haben scheint. Bitte gib eine korrekte Adresse ein oder leere das Feld. |
badretype | Die beiden Passwörter stimmen nicht überein. |
userexists | Dieser Benutzername ist schon vergeben.
Bitte wähle einen anderen. |
captcha-createaccount-fail | Falsches oder fehlendes CAPTCHA. |
acct_creation_throttle_hit | Besucher dieses Wikis, die deine IP-Adresse benutzen, haben während des letzten Tages num Benutzerkonten erstellt. Dies ist die maximal erlaubte Anzahl in diesem Zeitraum.
Daher können Besucher, die diese IP-Adresse benutzen, derzeit keine weiteren Benutzerkonten erstellen. Falls du dich auf einer Veranstaltung befindest, die sich auf die Mitwirkung bei Wikimedia-Projekten fokussiert, beantrage bitte eine temporäre Aufhebung der IP-Sperre, um bei der Lösung dieses Problems zu helfen. |
Zusätzliche Anmerkungen
- Kontenerstellungen werden in Special:log/newusers aufgezeichnet.
Wenn du angemeldet bist wird auch dein Benutzername bei der Kontenerstellung gespeichert.
- Beachte beim Ausführen der Code-Ausschnitte auf dieser Seite:
- Sobald ein Konto in einem Wiki erstellt wurde, kann es nicht gelöscht werden.
- Nutze immer
https://test.wikipedia.org/w/api.php
als Endpunkt, damit du nicht versehentlich Konten in echten Wikis erstellst.
- MediaWiki-Seiten-Administratoren und Erweiterungsentwickler können diese API-Funktion durch das Einfügen folgender Zeile in die Konfigurationsdatei deaktivieren:
$wgAPIModules['createaccount'] = 'ApiDisabled';