API:Vytvoření účtu

This page is a translated version of the page API:Account creation and the translation is 100% complete.

Tato stránka je součástí dokumentace k API Action MediaWiki.

Verze MediaWiki:

≥ 1.27

Tato stránka dokumentuje API pro vytváření účtů od MediaWiki 1.27. Dokumentace API, jak existovala v dřívějších verzích, je k dispozici zde: Api:Account creation/pre-1.27 .

Dokumentace API

Následující dokumentace je výstupem Special:ApiHelp/createaccount, automaticky generovaným pre-release verzí MediaWiki, která je spuštěna na tomto webu (MediaWiki.org).

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:

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.

https://www.mediawiki.org/wiki/Special:MyLanguage/API:Account_creation

Specific parameters:

Other general parameters are available.

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.

Example:

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]

Vytvoření účtu

Proces se skládá ze tří obecných kroků:

Získejte pole z API:Authmanagerinfo a token z API: Tokeny .
Odešlete požadavek POST s načteným tokenem, informacemi o uživateli a dalšími poli a vraťte URL do API.
Vypořádejte se s odpovědí, která může zahrnovat další požadavky POST na poskytnutí dalších informací.

Příklad 1: Proces na wiki bez speciálních autentizačních rozšíření

Wiki bez speciálních autentizačních rozšíření může být poměrně jednoduchá. Pokud váš kód ví, která pole budou vyžadována, může přeskočit volání na API:Authmanagerinfo a pouze předpokládat, která pole budou potřeba (tj. uživatelské jméno, heslo a znovu zadané heslo, e-mail, případně skutečné jméno).

Pokud vytváříte účet pro někoho jiného, budete muset uvést důvod pro totéž přidáním parametru reason do požadavku POST. Můžete také použít mailpassword místo parametrů password a retype, aby MediaWiki poslala novému uživateli dočasné heslo e-mailem.

Požadavek POST

api.php?action=createaccount&createreturnurl=http://example.com/&createtoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&username=zane&password=password&retype=password&email=zane@example.com&format=json [zkuste v ApiSandbox]

Odpověď

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

Ukázkový kód

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 );
	} );
} );

Příklad 2: Proces na wiki s příponou CAPTCHA

Všimněte si, že první krok níže lze, pokud byste raději, provést jako dva kroky: Jeden pro načtení polí dostupných z API:Authmanagerinfo a druhý pro načtení tokenu z API: Tokeny .

První krok: Načtěte pole dostupná od API:Authmanagerinfo a token od API: Tokeny

api.php?action=query&meta=authmanagerinfo|tokens&amirequestsfor=create&type=createaccount [zkuste v ApiSandbox]

Výsledek

{
    "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+\\"
        }
    }
}

Druhý krok: Odešlete žádost o příspěvek spolu s tokenem pro vytvoření účtu, informacemi o uživateli a návratovou adresou URL

api.php?action=createaccount&createreturnurl=http://example.com/&createtoken=9ed1499d99c0c34c73faa07157b3b6075b427365+\&username=Amy&password=password&retype=password&email=amy@example.com&captchaId=70020580&captchaWord=winedtyping [zkuste v ApiSandbox]

Výsledek
{ "createaccount": { "status": "PASS", "username": "Zane" } }

Ukázkový kód

Všimněte si, že tato ukázka kódu odděluje požadavky API:Authmanagerinfo a API: Tokeny a obecně předpokládá, že bude CAPTCHA a žádné další komplikace.

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>

Příklad 3: Vytvoření účtu na wiki s povoleným CAPTCHA, rozšířením OpenID a rozšířením dvoufaktorové autentizace

První krok: Načtěte pole dostupná od API:Authmanagerinfo a token od API: Tokeny

Načítání API:Authmanagerinfo a API: Tokeny je z velké části stejné jako v předchozím příkladu, a proto se zde neopakuje. Seznam požadavků vrácených API:Authmanagerinfo bude obsahovat definice pro rozšíření CAPTCHA i rozšíření OpenID.

Druhý krok: Odpovězte na CAPTCHA a vyberte ověřování OpenID.

api.php?action=createaccount&createreturnurl=http://example.com/authenticating.php&createtoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&captchaId=12345&captchaWord=MediaWikiIsCool&username=Alice&openIdProvider=openid.example.net&useOpenId=1 [zkuste v ApiSandbox]

Výsledek

{
    "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"
                    },
                }
            }
        ]
    }
}

Od klienta by se očekávalo, že přesměruje prohlížeč uživatele na zadaný redirecttarget.

Poskytovatel OpenID by se ověřil a přesměroval na Special:OpenIDConnectReturn na wiki, což by ověřilo odpověď OpenID a poté by přesměrovalo na createreturnurl uvedenou v prvním POST na rozhraní API s kódem< Byly přidány parametry /var> a state.

Klient získá kontrolu nad procesem zpět v tomto okamžiku a provede svůj další požadavek API.

Třetí krok: Zpět z OpenID.

Klient odešle kód a stav zpět do API. Odpověď API má rozšíření dvoufaktorové autentizace, které uživatele vyzve k nastavení druhého faktoru.

api.php?action=createaccount&createcontinue=1&createtoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&code=SplxlOBeZQQYbYS6WxSbIA&state=XYZ123 [zkuste v ApiSandbox]

Výsledek

{
    "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"
                    }
                }
            }
        ]
    }
}

Nyní klient vyzve uživatele, aby si ve své aplikaci pro dvoufaktorovou autentizaci vytvořil nový účet a zadal aktuální kód, nebo by uživateli umožnil přeskočit nastavení 2FA. Předpokládejme, že uživatel nastavil 2FA.

Čtvrtý krok: Nastavte dvoufaktorové ověřování.

api.php?action=createaccount&createcontinue=1&createtoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&code=817420 [zkuste v ApiSandbox]

Výsledek
{ "createaccount": { "status": "PASS", "username": "Alice" } }

Vytvoření účtu se nakonec podařilo.

Pokud se vytvoření účtu v kterémkoli okamžiku nezdaří, bude vrácena odpověď se stavem FAIL spolu se zprávou, která se zobrazí uživateli.

Možné chyby


Kód	Popis
badtoken	Neplatný token pro vytvoření účtu
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" a "createreturnurl" is required.
authmanager-create-no-primary	Uvedené přihlašovací údaje nelze použít pro založení účtu.
noemailcreate	Musíte uvést platnou e-mailovou adresu
invalidemailaddress	Zadaná e-mailová adresa nemůže být přijata, neboť nemá správný formát. Zadejte platnou e-mailovou adresu nebo obsah tohoto pole vymažte.
badretype	Vámi napsaná hesla nesouhlasí.
userexists	Zadané uživatelské jméno se již používá. Zvolte si prosím jiné jméno.
captcha-createaccount-fail	Chybějící či neplatný potvrzovací kód.
acct_creation_throttle_hit	Uživatelé používající vaši IP adresu za poslední den vytvořili už num účtů, což je pro toto období maximum. Proto není v tuto chvíli dovoleno z této IP adresy zakládat další účty. Pokud se účastníte události, která se zaměřuje na přispívání do projektů Wikimedia, podívejte se na Žádost o dočasné zrušení omezení pro IP adresu, aby šlo tento problém vyřešit.

Další poznámky

Vytvoření účtu se zaznamenává v Special:log/newusers.

Pokud jste přihlášeni, bude při vytváření účtu zaznamenáno i vaše uživatelské jméno.

Při provádění úryvků kódu uvedených na této stránce nezapomeňte:
- Jakmile je účet na wiki vytvořen, nelze jej smazat.
- Vždy používejte https://test.wikipedia.org/w/api.php jako koncový bod, abyste omylem nevytvářeli účty v produkci wiki.
administrátoři stránek a vývojáři rozšíření MediaWiki mohou tuto funkci API zakázat vložením následujícího řádku do konfiguračního souboru:

$wgAPIModules['createaccount'] = 'ApiDisabled';

Související odkazy

Jak omezit používání API