API:खाता निर्माण
 | यह पृष्ठ मीडियाविकि प्रतिक्रिया API प्रलेख का हिस्सा है। |
| मीडियाविकि संस्करण: | ≥ 1.27 |
यह पृष्ठ मीडियाविकि 1.27 के खाता निर्माण API को प्रलेखित करता है। पिछले संस्करणों में मौजूद API का प्रलेखन यहाँ मौजूद है: Api:Account creation/pre-1.27।
API प्रलेख
खाता बनाना
इस प्रक्रिया में साधारणतः तीन चरण हैं:
- API:Authmanagerinfo से फील्ड्स और API:Tokens से टोकन को लाना।
- लाए गए टोकन, सदस्य की जानकारी और दूसरे फील्ड्स के साथ एक POST अनुरोध भेजना और API को URL लौटा देना।
- जवाब का ठिकाना लेना, जिसे अधिक जानकारी के लिए और POST अनुरोधों की आवश्यकता भी हो सकती है।
उदाहरण 1: विशेष प्रमाणीकरण एक्सटेंशनों के अलावा विकि पर प्रक्रिया
किसी विशेष प्रमाणीकरण के बग़ैर विकि पर यह प्रक्रिया काफी सीधी-साधी है। अगर आपके कोड को पता है कि किन फील्ड्स की आवश्यकता होगी, यह शायद API:Authmanagerinfo के कॉल को छोड़ दे और अंंदाज़ा लगा ले कि कौन-से फील्ड्स चाहिए होंगे (यानी सदस्यनाम, पासवर्ड और दोबारा लिखा गया पासवर्ड, ईमेल, शायद असली नाम)।
अगर आप किसी और के लिए खाता बना रहे हैं, आपको POST अनुरोध में
reason पैरामीटर में इसका एक कारण दर्ज करना होगा। आप मीडियाविकि को ईमेल के द्वारा नए सदस्य को एक अस्थायी पासवर्ज भिजवाने के लिए password और retype पैरामीटरों की जगह mailpassword का भी उपयोग कर सकते हैं।
POST अनुरोध
जवाब
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
उदाहरण कोड
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 );
} );
} );
उदाहरण 2: CAPTCHA एक्सटेंशन वाले विकि पर प्रक्रिया
अगर आप चाहे तो इसमें पहले चरण को दो अलग-अलग चरणों में बाँट सकते हैं: API:Authmanagerinfo से उपलब्ध फील्ड्स लाने के लिए एक और API:Tokens से टोकन लाने के लिए एक।
<span id="First_step:_Fetch_fields_available_from_API:Authmanagerinfo_and_token_from_API:Tokens">
पहला चरण: API:Authmanagerinfo से फील्ड्स और API:Tokens से टोकन लाना
api.php?
| Result |
|---|
{
"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+\\"
}
}
}
|
दूसरा चरण खाता निर्माण टोकन और सदस्य की जानकारी के साथ एक POST अनुरोध भेजना और URL लौटाना
api.php?
| Result |
|---|
{
"createaccount": {
"status": "PASS",
"username": "Zane"
}
}
|
उदाहरण कोड
ध्यान रखें कि यह उदाहरण API:Authmanagerinfo और API:Tokens अनुरोधों को अलग-अलग कर देता है और अंदाज़ा लगाता है कि विकि पर सिर्फ CAPTCHA ही होगा।
| 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>
|
उदाहरण 3: CAPTCHA, OpenID एक्सटेंशन और सक्षम दो-कारक प्रमाणीकरण वाले विकि पर खाता निर्माण
<span id="First_step:_Fetch_fields_available_from_API:Authmanagerinfo_and_token_from_API:Tokens">
पहला चरण: API:Authmanagerinfo से फील्ड्स और API:Tokens से टोकन लाना
API:Authmanagerinfo और API:Tokens को लाने की प्रक्रिया पिछले उदाहरण जैसी ही है तो इसे दोहराया नहीं गया है। API:Authmanagerinfo द्वारा लौटाए गए अनुरोधों की सूची में CAPTCHA एक्सटेंशन और OpenID एक्सटेंशन की परिभाषाएँ भी मौजूद होंगी।
दूसरा चरण: CAPTCHA का जवाब देना और OpenID प्रमाणीकरण चुनना।
api.php?
| Result |
|---|
{
"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"
},
}
}
]
}
}
|
क्लाइंट से प्रदान किए redirecttarget पर सदस्य के ब्राउज़र को अनुप्रेषित करने की अपेक्षा रहेगी।
OpenID प्रदानकर्ता प्रमाणीकृत करके विकि पर Special:OpenIDConnectReturn पर अनुप्रेषित कर देगा, जो OpenID के जवाब को स्वीकार कर लेगा, और code और state पैरामीटर वाले API के पहले POST में दिए गए createreturnurl पर अनुप्रेषित कर देगा।
क्लाइंट को प्रक्रिया का नियंत्रण दे दिया जाता है और यह अपना अगला API अनुरोध करता है।
तीसरा चरण: OpenID से वापस।
क्लाइंट code और state API को वापस पोस्ट कर देता है। API के जवाब में दो-कारक प्रमाणीकरण एक्सटेंशन है जिसकी मदद से सदस्य अपने दूसरे कारक को सेट कर सकता है।
api.php?
| Result |
|---|
{
"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"
}
}
}
]
}
}
|
अब क्लाइंट सदस् को अपने दो-कारक प्रमाणीकरण ऐप पर एक नया खाता बनाने को और वर्तमान कोड दर्ज करने को कहेगा, या फिर सदस्य को 2FA को रद्द करने का विकल्प देगा। मान लेते हैं कि सदस्य 2FA का उपयोग नहीं करता है।
चौथा चरण: दो-कारक प्रमाणीकरण का उपयोग।
api.php?
| Result |
|---|
{
"createaccount": {
"status": "PASS",
"username": "Alice"
}
}
|
खाते का निर्माण सफल हुआ।
अगर खाते का निर्माण किसी भी समय असफल होता है, स्थिति FAIL वाला जवाब दिया जाएगा और साथ में सदस्य को दिखाने के लिए एक message भी।
संभव त्रुटियाँ
| कोड | जानकारी |
|---|---|
| badtoken | अमान्य खाता निर्माण टोकन |
| 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" और "createreturnurl" is required. |
| authmanager-create-no-primary | खाता निर्माण के लिए आपूर्ति की गई क्रेडेंशियल्स का उपयोग नहीं किया जा सका। |
| noemailcreate | आपको वैध ई-मेल पता देने होगा। |
| invalidemailaddress | ई-मेल पता नहीं माना जा सकता क्योंकि ये किसी अवैध स्वरूप में है।
कृपया एक सही तरीके से स्वरूपित ई-मेल पता दें अथवा उस कोष्ठक को रिक्त ही रहने दें। |
| badretype | आपने जो कूटशब्द दिये हैं वे एक दूसरे से नहीं मिलते। फिर से लिखें। |
| userexists | आपका दिया सदस्यनाम पहले से प्रयोग में है।
कृपया कोई अन्य सदस्यनाम चुनें। |
| captcha-createaccount-fail | केप्चा गलत या खाली है। |
| acct_creation_throttle_hit | आपके आईपी पते का उपयोग कर इस विकि के लिए आगंतुकों अंतिम दिन में 1 खातें बनाएँ हैं, जो इस समय मे अधिकतम अनुमति प्राप्त संख्या।
इसलिए, इस आइपी पते का उपयोग करके आगंतुकों इस समय किसी भी अधिक खाता नहीं बना सकते हैं। यदि आप कोई घटना मे हैं जो विकिमीडिया परियोजनाओं के लिए योगदान पर हैं ध्यान केंद्रित है, तो इस समस्या को सुलझाने को मदद करने के लिए Requesting temporary lift of IP cap देखें। |
अतिरिक्त टिप्पणियाँ
- खातों के निर्माणों को Special:log/newusers पर रिकॉर्ड किया जाता है।
अगर आपने लॉग-इन किया है, खाता बनाते समय आपके सदस्यनाम को भी रिकॉर्ड किया जाएगा।
- इस पृष्ठ पर प्रदान किए गए कोड स्निपेट्स का उपयोग करते समय याद रखें:
- एक बार खाता बना लेने के बाद इसे हटाया नहीं जा सकता।
- हमेशा एंडपॉइंट के रूप में
https://test.wikipedia.org/w/api.phpका उपयोग करें ताकि आप गलती से मुख्य विकियों पर खाते न बना दें।
- मीडियाविकि के साइट प्रबंधक और एक्सटेंशन विकासक कॉन्फिगरेशन फाइल में यह पंक्ति दर्ज करके इस API सुविधा को अक्षम कर सकते हैं:
$wgAPIModules['createaccount'] = 'ApiDisabled';