Manual:Pages spéciales

This page is a translated version of the page Manual:Special pages and the translation is 100% complete.

Extensions :

Les pages spéciales sont des pages créées par le logiciel en vue de réaliser une fonction spécifique.

Par exemple, une page spéciale présente toutes les pages qui ont un ou plusieurs liens avec un site internet ; une autre peut créer un formulaire donnant la liste des commentaires émis par l'utilisateur.

Les pages spéciales sont stockées dans leur propre espace de noms (Special:) et ne sont pas directement modifiables comme les autres pages. Les Développeurs peuvent aussi créer de nouvelles pages spéciales.

Ces pages sont, par défaut, accessibles aux utilisateurs et seront généralement présentées dans la liste des pages spéciales sur Special:SpecialPages. Quelques pages spéciales ne sont accessibles qu'à des utilisateurs possédant certains droits et certains accès autorisés. D'autres pages spéciales ne sont pas présentées du tout dans la liste des pages spéciales car elles sont uniquement utilisées en interne par le wiki.

Informations générales

Toutes les pages spéciales fournies par défaut avec MediaWiki sont appelées SpecialSomename.php et sont situées dans le répertoire includes/specials . Les pages spéciales du coeur doivent être enregistrées dans la liste système située dans includes/specialpage/SpecialPageFactory.php pour être chargées par MediaWiki. Les pages spéciales créées par des développeurs tiers sont généralement enregistrées dans le répertoire extensions dans leur propre fichier ou comme partie d'une extension plus grande. Toutes les pages spéciales héritent d'une classe appelée SpecialPage définie dans includes/specialpage/SpecialPage.php. Quand une nouvelle page spéciale est créée, les droits utilisateur nécessaires pour accéder à la page peuvent être définis. Ces droits spécifient, entre autres choses, si la page doit être affichée sur Special:SpecialPages et si la page peut être incluse dans d'autres pages.

Les pages spéciales ont aussi des noms uniques qui peuvent être adaptés sur un wiki. La forme générale est « Special:Pagename » où à la fois « Special » et « Pagename » sont adaptables. Le pseudo namespace de Special peut être traduit en d'autres langues. Cet espace de noms traduit peut être produit avec le texte wiki {{ns:special}}, sur ce wiki donnant ainsi « Special ». Le nom de la page spéciale peut aussi être redéfini dans un message système, pour la langue du site, avec le nom générique de la page spéciale pour identifiant (ID).

Une page spéciale peut ou non accepter des entrées. Par exemple, Special:Export permet à un utilisateur de définir une page spécifique à exporter en appelant Special:Export/Sun. Si la page spéciale permet des entrées complexes, les paramètres additionnels seront envoyés au composant de la chaîne de requête de l'URL pour traitement, par exemple : https://www.mediawiki.org/w/index.php?title=Special:Recentchanges&days=3&limit=250.

Il y a différentes manières de faire des pages spéciales, mais celle présentée ci-dessous est utilisée par le gros des extensions officielles, et il est recommandé de suivre ce schéma. Aussi, assurez-vous d'inclure un bloc de crédits dans la nouvelle page spéciale pour 'specialpage'. Voir $wgExtensionCredits pour plus de détails.
Après avoir créé une nouvelle page spéciale, assurez-vous de l'ajouter à Catégorie:Extensions des pages spéciales afin que d'autres personnes puissent la trouver.
Les pages spéciales ne peuvent pas être incluses dans des cadres (frames) à moins que vous n'utilisiez $wgOut->allowClickjacking();

Modèle de page spéciale de base

MediaWiki 1.25 a introduit une nouvelle manière de charger une extension. Pour les versions de MediaWiki plus anciennes qui ne sont plus prises en charge, voir une ancienne version.

La plupart des pages spéciales d'extensions ont besoin de trois fichiers :

un petit fichier de configuration, qui se charge à chaque fois que MediaWiki démarre.
un fichier avec le gros du code.
un fichier de messages traduits dans la langue locale

Les conventions de codage dans MediaWiki définissent ces trois fichiers ainsi :

MyExtension/extension.json – Le fichier de configuration.
MyExtension/includes/Special.php – Le code de page spécial.
i18n/*.json – Le fichier de localisation .

Placez tous les fichiers dans un nouveau répertoire à l'intérieur du répertoire extensions/ dans votre MediaWiki.

Il faut nommer le fichier de la page spéciale avec le nom de l'extension. Par exemple, Extension:Gadgets contient le fichier SpecialGadgets.php. Si votre extension utilise plus d'une page spéciale, vous aurez besoin de noms supplémentaires.

Dans l'exemple ci-dessous, le nom de la page spéciale est MyExtension.

Après avoir créé les fichiers listés ci-dessous, si on ajoute les lignes suivantes à LocalSettings.php, on active l'extension :

wfLoadExtension( 'MyExtension' );

Fichier de configuration

Exemple de fichier de configuration pour MyExtension/extension.json :

{
	"name": "MyExtension",
	"version": "0.0.0",
	"author": [
		"Your Name"
	],
	"url": "https://www.mediawiki.org/wiki/Extension:MyExtension",
	"descriptionmsg": "myextension-desc",
	"license-name": "MIT",
	"type": "other",
	"AutoloadNamespaces": {
		"MediaWiki\\Extension\\MyExtension\\": "src/"
	},
	"SpecialPages": {
		"MyExtension": "MediaWiki\\Extension\\MyExtension\\Special"
	},
	"MessagesDirs": {
		"MyExtension": [
			"i18n"
		]
	},
	"manifest_version": 2,
	"requires": {
		"MediaWiki": ">= 1.41.0",
		"platform": {
			"php": ">= 5.6"
		},
		"extensions": {
			"dependendExtension": "*"
		}
	}
}

Ce fichier enregistre plusieurs éléments importants et obligatoires :

Emplacement de la classe MediaWiki\Extension\MyExtension\Special ;
Emplacement des fichiers de localisation ;
La nouvelle page spéciale et son nom de classe.

Si vous obtenez l'erreur InvalidArgumentException: Provided specification is not an array, cela signifie généralement que MediaWiki n'a pas pu trouver la classe spécifiée dans extension.json qui implémentera votre page spéciale.

Le fichier de page spéciale

Le fichier corps (MyExtension/src/Special.php) doit contenir une sous-classe de SpecialPage ou l'une de ses sous-classes. Ce fichier se charge automatiquement lorsque quelqu'un demande la page spéciale. L'exemple ci-dessous implémente la sous-classe SpecialMyExtension.

Il faut disposer du constructeur de __construct() car son premier paramètre est le nom de votre page spéciale.

execute() est la fonction principale appelée quand une page spéciale est accédée. Cette fonction supplante la fonction SpecialPage::execute(). Elle passe le paramètre unique $par, qui est le composant sous-page du titre actuel. Par exemple, si on choisit de suivre un lien vers Special:MyExtension/blah, $par va contenir « blah ».

Vous devez exécuter la génération du Wikitext et du HTML via $wgOut. N'utilisez pas 'print' ni 'echo' directement lorsque vous travaillez avec les interfaces utilisateur du wiki.

Néanmoins, si vous utilisez votre page spéciale comme point d'accès pour personnaliser la sortie XML ou binaire, voyez Prendre la main sur les sorties dans votre page spéciale .

<?php
namespace MediaWiki\Extension\MyExtension;
class SpecialMyExtension extends \SpecialPage {
	public function __construct() {
		parent::__construct( 'MyExtension' );
	}

	public function execute( $par ) {
		$request = $this->getRequest();
		$output = $this->getOutput();
		$this->setHeaders();

		# Obtenez les données demandées, par exemple
		$param = $request->getText( 'param' );

		# Faites le travail
		# ...
		$wikitext = 'Hello world!';
		$output->addWikiTextAsInterface( $wikitext );
	}
}

Le fichier de localisation

Voir Messages système pour connaître la manière de traduire les fichiers de localisation.

Toutes les pages spéciales ont un titre, comme 'My Extension'.

Le titre est utilisé dans les éléments ‎<title> et ‎<h1> de la page de l'extension et sur Special:SpecialPages.
Cela peut être ce que vous voulez, mais il doit décrire la page spéciale et l'extension.
Il est spécifié par un message. La structure du message est une paire clé-valeur. La clé 'myextension', doit être entièrement en minuscules.

Exemple de ficher de localisation en MyExtension/i18n/en.json :

{
	"@metadata": {
		"authors": [
			"<your username>"
		]
	},
	"myextension": "My Extension",
	"myextension-desc": "Adds the MyExtension functionality.",
	"myextension-summary": "On this special page, do this simple thing and earn wonders.",
	"group-myextensionrole": "Role of myextension",
	"group-myextensionrole-member": "Member of role of myextension",
	"grouppage-myextensionrole": "{{ns:project}}:Role of myextension",
	"action-myextension": "XYZ doing.",
	"right-myextension": "to do xyz"
}

Dans i18n/qqq.json, la documentation du message :

{
	"@metadata": {
		"authors": [
			"<your username>"
		]
	},
	"myextension": "The name of the extension's entry in Special:SpecialPages",
	"myextension-desc": "{{desc}}",
	"myextension-summary": "Description appearing on top of Special:MyExtension.",
	"action-myextension": "{{doc-action|myextension}}",
	"right-myextension": "{{doc-right|myextension}}"
}

Notez que les IDs ne doivent pas commencer par une lettre majuscule, et qu'une espace dans l'ID doit être remplacée par un caractère souligné '_' dans le code.

Le message -summary est optionnel. La création se fait automatiquement via la classe parent et s'affiche en haut de la page spéciale, habituellement avec une description concise de ce que l'utilisateur peut en faire. Si vous ne définissez pas son contenu, il ne sera utilisé que lorsque les administrateurs wiki vont le personnaliser sur le wiki.

Le fichier d'alias

Vous pouvez aussi internationaliser le nom de la page spéciale en créant pour elle des alias. L'exemple ci-dessous utilise le fichier « MyExtension.i18n.alias.php ». Dans cet exemple, le page spéciale MyExtension enregistre un alias de sorte que la page devient accessible par .../Special:My Extension et .../Spezial:Meine_Erweiterung en allemand.

Ajoutez votre fichier d'alias à extension.json :

...
	"ExtensionMessagesFiles": {
		"MyExtensionAlias": "MyExtension.i18n.alias.php"
	},
...

Ajoutez les alias des pages spéciales à MyExtension.i18n.alias.php :

<?php
/**
 * Aliases for myextension
 *
 * @file
 * @ingroup Extensions
 */

$specialPageAliases = [];

/** English
 * @author <votre nom d'utilisateur>
 */
$specialPageAliases['en'] = [
	'MyExtension' => [ 'MyExtension', 'My Extension' ],
];

/** Deutsch
 * @author <votre nom d'utilisateur>
 */
$specialPageAliases['de'] = [
	'MyExtension' => [ 'MeineErweiterung', 'Meine Erweiterung' ],
];

Encore une fois, vous devez écrire une espace dans l'ID et un caractère souligné '_' dans le code.

Pour l'entête de la page et les liens, les règles habituelles concernant les noms de pages s'appliquent.

Si $wgCapitalLinks est à true, une lettre minuscule est convertie en majuscule, et un caractère souligné est affiché à la place de l'espace.

Par exemple, à la place de ce qui est ci-dessus, vous pouvez utiliser 'my_extension' => 'My extension', en supposant que l'extension a bien été identifiée ailleurs comme my_extension .

Notez que dans le cas d'un tableau associatif en anglais, la chaîne qui identifie la page spéciale (MyExtension dans l'exemple) est aussi un titre valide.

Notez également que le premier élément de $specialPageAliases['en']['MyExtension'] doit être le même que la clé ('MyExtension')! Sinon Special:Specialpages ne listera pas la page.

Groupe des pages spéciales

Vous pouvez initialiser le groupe dans lequel votre page spéciale apparaîtra sur Special:SpecialPages, en réécrasant SpecialPage::getGroupName() dans votre sous-classe.

    /**
     * Modifiez le parent pour définir où la page spéciale apparaîtra sur Special:SpecialPages
     * 'other' est la valeur par défaut. Si c'est ce que vous désirez, il n'y a rien à modifier.
     * Specifiez 'media' pour utiliser le message d'interface système <code>specialpages-group-media</code> , qui traduit en anglais 'Rapports de media et téléversements';
     * 
     * @return string
     */
    function getGroupName() {
        return 'media';
    }

Quelques valeurs communes sont 'login', 'maintenance', 'media', 'other', 'pagetools', 'redirects', 'users'. Vous pouvez voir les valeurs acceptées sur Special:AllMessages (cherchez specialpages-group) ou cherchez sur le wiki en utilisant le pseudo langage 'qqx' en allant à Special:SpecialPages?uselang=qqx) et en regardant les titres. Spécifiez le mot 'media' pour utiliser le message d'interface 'specialpages-group-media'.

Si votre page spéciale ne correspond à aucun des titres préconfigurés, vous pouvez ajouter un nouveau titre en le mettant dans votre fichier de localisation, voir Le fichier de localisation).

Les groupes de pages standards venant avec MediaWiki sont listés dans le fichier de localisation. Par exemple, les messages anglais sont en languages/i18n/en.json et commencent avec specialpages-group-. Si vous voulez catégoriser votre page spéciale sous users, alors le message est specialpages-group-users. La valeur de cette clé est le texte qui apparaît comme le nom de cette catégorie, par exemple, Users and rights.

Si votre page spéciale semble ne rentrer dans aucune des catégories existantes, vous pouvez toujours en créer une nouvelle. Dans le fichier de localisation de votre extension insérez simplement une nouvelle clé pour le tableau messages . Dans cet exemple, nous définissons le groupe gamification :

{
    "myextension": "My Extension",
	"myextension-desc": "Adds the MyExtension functionality.",
	"myextension-summary": "On this special page, do this simple thing and earn wonders",
	"specialpages-group-gamification": "Gamification"
}

Maintenant, en supposant que vous initialisiez la valeur de retour pour la méthode SpecialPage::getGroupName() à gamification dans la définition de votre classe, rechargez Special:SpecialPages pour voir votre nouvelle catégorie.

Autres fichiers importants

SpecialPage.php

Constructeur

Vous pouvez surcharger le constructeur pour initialiser vos propres données, mais la raison principale de faire cela est parce que vous voulez modifier le comportement de la classe SpecialPage elle-même. Lorsque vous appelez le constructeur de la classe de base à partir de votre classe enfant, les paramètres suivants sont disponibles :

function __construct( $name = '', $restriction = '', $listed = true );

string $name Nom de la page spéciale, tel qu'il apparait dans les liens et les URLs
string $restriction Droit utilisateur nécessaire, par exemple « block » ou « delete » ; voir aussi Restreindre l'accès à la page
boolean $listed Si la page doit apparaître dans Special:Specialpages

`SpecialPage->setHeaders()`

Ceci initialise l'objet OutputPage $wgOut avec le nom et la description de votre page spéciale. Doit toujours être appelé à partir de votre méthode execute().

`SpecialPage->getOutput()`

Cette méthode rend un objet OutputPage qui peut être accédé comme indiqué ci-dessous. Comme dans le code d'exemple, utilisez

$output = $this->getOutput();
$output->addWikiTextAsInterface( 'Hello, World' );

au lieu de la variable globale $wgOut obsolète

`SpecialPage->getRequest()`

Cette méthode retourne un objet WebRequest qui peut être accédé comme décrit ci-dessous. Comme dans le code d'exemple, utilisez

$request = $this->getRequest();
$myparam = $request->getText( 'myparam' );

au lieu de la variable globale obsolète $wgRequest

`SpecialPage->including()`

Certaines pages spéciales peuvent être incluses à partir d'autres pages. Par exemple, si vous ajoutez {{Special:RecentChanges}} dans le wikicode d’une page, cela va insérer une liste des modifications récentes à l'intérieur du contenu existant de la page.

Il est possible d’inclure une page spéciale dans une autre page web uniquement s’il est déclaré dans son constructeur qu’elle peut être incluse. Vous pouvez faire cela en ajoutant ce qui suit dans la méthode __construct() après l'initialisation de la classe parent :

$this->mIncludable = true;

Vous pouvez aussi définir votre classe de page spéciale comme une extension de la classe IncludableSpecialPage.

La fonction SpecialPage->including() retourne une valeur booléenne qui vous renseigne sur le contexte à partir duquel la page spéciale va être appelée : false si c'est une page web séparée, et true si elle va être incluse à partir d'une autre page web. Habituellement, vous voudrez peut-être alléger quelque peu la présentation si la page doit être incluse.

`SpecialPage->execute()`

Ceci est la fonction que votre classe fille doit surcharger. Elle passe un paramètre unique, habituellement référencé de manière codée comme $par (raccourci pour $parameter, parce qu'il est le paramètre que les utilisateurs peuvent remplir pour votre page spéciale). Ce paramètre est le composant sous-page du titre actuel. Par exemple, si quelqu'un suit un lien vers Special:MyExtension/blah, $par va contenir « blah ».

Page d'aide

Version de MediaWiki :

≥ 1.25

Il est utile de mettre les pages d'aide sur MediaWiki.org, c'est là qu'elles pourront être traduites. Pour être sûr que les utilisateurs trouveront vos pages d'aide, il est conseillé et très simple que votre page spéciale pointe vers la page d'aide en question :

$this->addHelpLink( 'Help:Extension:MyExtension' );

OutputPage.php

OutputPage.php contient la définition de classe pour les objets de type OutputPage. Vous pouvez obtenir un objet de cette classe de votre page spéciale en utilisant :

$output = $this->getOutput();

Le nom de variable $output est, bien sûr arbitraire. Peu importe la manière dont vous l'appelez, il s'agit de la variable que vous utiliserez le plus parce que c'est la manière d'envoyer les sorties vers le navigateur (non, on n'utilise pas echo ni print). Si vous voulez l'utiliser ailleurs, déclarez la variable et utilisez-la :

function randomFunction() {
	$output = $this->getOutput();
	$output->addHTML( '<b>This is not a pipe...</b>' );
}

Si vous le désirez, vous pouvez créer plusieurs objets OutputPage dans différentes méthodes de votre extension SpecialPage. Ils s'ajouteront à la sortie dans l'ordre où ils sont exécutés.

Vous pouvez voir la classe OutputPage en affichant includes/OutputPage.php (bien sûr, toutes les classes sont visualisables), mais il existe quelques méthodes que vous devez absolument connaître.

`OutputPage->addHTML()`

C'est essentiellement un substitut rapide et sale de echo. Il prend vos entrées et les ajoute dans le buffer: sans poser de question. Dans l'action ci-dessous, si $action contient des données utilisateur, elle peut facilement contenir du XSS, du matériel diabolique, ou un rejeton de Satan à l'intérieur. Vous feriez mieux d'utiliser un échappement (comme avec la fonction php htmlentities) ou la classe de générateurs XML pour générer une sortie sécurisée.

$output->addHTML( '<form action="'.$action.'" method="post">' );

`OutputPage->addWikiText()`

Pour la plupart des sorties, vous devriez utiliser cette fonction. C'est un peu une fonction de magie noire : on entre du texte wiki, HTML apparaît, et tout un code mystérieux et des invocations de démons se produisent entre les deux.

$output->addWikiText("This is some ''lovely'' [[wikitext]] that will '''get''' parsed nicely.");

Il est à noter que l’analyseur syntaxique considère vos morceaux comme des ensembles cohérents et les paragraphes aussi. C'est à dire que ...

$output->addWikiText( '* Item 1' );
$output->addWikiText( '* Item 2' );
$output->addWikiText( '* Item 3' );

va générer trois listes avec chacune un élément qui probablement n'a pas été attendu.

Notez néanmoins que, si vous voulez simplement insérer un message système et que vous l'avez traité comme du texte wiki analysé, vous pouvez utiliser du code comme $this->getOutput()->addHtml( $this->msg( 'key-of-message' )->parse() ). Ceci ne présentera pas le problème des appels imbriqués à l'analyseur mentionnés ci-dessus.

`OutputPage->showErrorPage()`

Une page d'erreur est affichée. Les arguments $title et $msg spécifient les clés dans $this->msg(), et non pas le texte. Par exemple :

$output->showErrorPage( 'error', 'badarticleerror' );

'error' fait référence au texte « Erreur ».
'badarticleerror' fait référence au texte « Cette action ne peut pas être effectuée sur cette page. ».

Vous pouvez aussi spécifier des objets de messages ou ajouter des paramètres :

$output->showErrorPage( 'error', 'badarticleerror', [ 'param1', 'param2' ] );

$messageObject = new Message(...);
...
$output->showErrorPage( 'error', $messageObject );

$titleMessageObject = new Message(...);
$messageObject = new Message(...);
...
$output->showErrorPage( $titleMessageObject, $messageObject );

WebRequest.php

La classe WebRequest est utilisée pour obtenir des informations à partir des tableaux GET et POST. Il est recommandé de l’utiliser plutôt que d’accéder directement aux superglobales. L'objet WebRequest est accessible aux extensions en utilisant le RequestContext .

Database.php

MediaWiki a une quantité de fonctions pratiques et de wrappers pour interagir avec la base de données, en utilisant la classe \Wikimedia\Rdbms\Database. Il dispose également d’un schéma de partage de charge intéressant. Il est recommandé d'utiliser ces conteneurs. Consultez la base de données Database.php pour obtenir une liste complète de toutes les fonctions pratiques, car ces documents ne vous présenteront que des mises en garde non évidentes. Voir Manuel: Accès à la base de données .

User.php

La classe User est utilisée pour représenter les utilisateurs du système. SpecialPage->getUser() doit être utilisé pour obtenir un objet User pour l'utilisateur actuellement connecté. L'utilisation de la variable globale $wgUser est obsolète

Title.php

Title représente le nom d'une page du wiki. Ceci est utile car MediaWiki utilise toutes sortes d’échappements amusants et une logique de casse particulière pour les noms de page. Ainsi, au lieu de lancer votre propre fonction de conversion de titre en URL, vous créez un objet Title avec le nom de votre page, puis utilisez getLocalURL() pour obtenir une URL de cette page.

Pour obtenir un objet pour le titre de votre page spéciale en dehors de la classe de page spéciale, vous pouvez utiliser SpecialPage::getTitleFor( 'YourCanonicalSpecialPageName' ). Cela vous donnera un titre internationalisé dans la langue du wiki.

Pages spéciales personnalisées

Il existe différentes manières de fournir vos propres pages spéciales non groupées dans MediaWiki :

Une méthode consiste à installer une extension qui génère un formulaire pour créer ou modifier un article. Une liste des extensions actuellement disponibles se trouve dans Catégorie:Extensions des pages spéciales .
Vous pouvez également écrire une extension qui fournit votre propre page spéciale. L'écriture de votre propre extension nécessite des connaissances en codage PHP et une connaissance approfondie de la conception orientée objet et des bases de données est également utile. Vous aurez également besoin de savoir comment utiliser le code pour créer et éditer des articles MediaWiki. Pour plus d'informations, consultez cette discussion.
Vous pouvez également afficher une page personnalisée via JavaScript, à la place du message d'erreur par défaut Page spéciale inconnue (ou du message Cette page est laissée vide intentionnellement, si vous utilisez une sous-page de Special:BlankPage). Dans MediaWiki:Common.js, recherchez wgPageName , puis masquez le contenu généré par MediaWiki (ajoutez uniquement le CSS {visibility:hidden;}) et insérez le code HTML personnalisé (innerHTML) dans le corps document.getElementById('bodyContent') ou document.getElementById('mw_contentholder'). Pour un exemple, voir meta:User:Krinkle/Tools/Real-Time Recent Changes.

Questions fréquentes

Définir un titre pour l'extension

MediaWiki n'initialise pas le nom de l'extension, c'est le travail du développeur. Il cherchera le nom de l'extension lorsque Special:Specialpages est appelé ou que la page spéciale est chargée. Dans la section function execute( $par ), utilisez les méthodes de OutputPage pour donner un titre à l’extension, par exemple : $this->getOutput()->setPageTitle("your title");

L’endroit où l’extension peut être trouvée (comme spécifié par ce qui est passé au constructeur de SpecialPage) est la clé -- excepté qu'elle n'est pas en majuscules à cause de getDescription(), la fonction interne utilisée qui recherche le titre (ou, ce qu’on appelle description) de la page spéciale, applique strtolower au nom. La clé de « ThisIsACoolSpecialPage» sera donc « thisisacoolspecialpage ».

Théoriquement, getDescription peut être surchargé afin d'éviter toute interaction avec le cache des messages mais, comme l'indique le code source: « Les classes dérivées peuvent redéfinir cela, mais il est généralement plus facile de conserver le comportement par défaut. De plus, cela empêche l'espace de noms MediaWiki de surcharger le message, comme ci-dessous.

Internationaliser le nom de l'extension

Donc, vous venez d'installer une nouvelle extension MediaWiki toute neuve et vous vous rendez compte que : « Oh non, mon wiki est en français, mais la page s'affiche en anglais! » La plupart des gens n'y font pas attention, mais c'est en fait une tâche assez simple à résoudre (tant que le développeur utilise la méthode expliquée sur cette page). Pas de nouille dans le code source. Supposons que le nom de la page soit DirtyPages et qu'il apparaisse dans « List of Dirty Pages » mais que vous le vouliez (et excusez mon pauvre français) à « Liste de Pages Sales ». Eh bien, c'est aussi simple que cela :

Allez sur MediaWiki:DirtyPages, celle page peut ne pas exister, mais modifiez-la de toute manière
Insérez « Liste de Pages Sales » et enregistrez

Voilà, la modification est appliquée.

Ceci est également utile pour personnaliser le titre de votre wiki dans votre langue: par exemple, le développeur l'a appelé « Liste des pages sales » mais vous n'aimez pas ce nom et vous voulez le renommer « Liste des pages nécessitant un nettoyage ». Voir Special:Allmessages pour en connaître davantage.

De même, si votre extension possède un grand bloc de texte qui ne change pas, comme un avertissement, ne sortez pas le texte directement. A la place, ajoutez-le au cache du message et quand le moment sera venu de sortir le texte dans votre code, faites ceci :

$wgOut->addWikiText( $this->msg( 'dirtypageshelp' ) );

Alors ce message aussi peut être personnalisé sur MediaWiki:Dirtypageshelp.

Voir aussi Messages système .

Restreindre l'accès aux pages

Ne pas afficher votre page spéciale sur Special:SpecialPages

Parfois, vous voudrez peut-être limiter la visibilité de votre page spéciale en la supprimant de Special:SpecialPages et en ne la rendant visible que pour les utilisateurs disposant d'un droit particulier. Vous pouvez faire cela dans le constructeur en passant dans un paramètre $restriction (par exemple « editinterface »), un droit uniquement attribué par défaut aux administrateurs (sysops); voir le Manuel des droits de l'utilisateur pour connaître les autres droits d'utilisateur disponibles.

function __construct() {
	parent::__construct( 'MyExtension', 'editinterface' ); // restreint aux administrateurs (sysops)
}

Ou vous pouvez créer vos propres droits dans le fichier setup et les assigner aux administrateurs (sysops) par exemple :

"AvailableRights": [
	"myextension-right"
],
"GroupPermissions": {
	"sysop": {
		"myextension-right": true
	}
}

et ensuite appelez le constructeur avec vos droits :

function __construct() {
	parent::__construct( 'MyExtension', 'myextension-right' );
}

Empêcher l'accès à votre page spéciale

Même si vous restreignez votre page dans le constructeur, comme mentionné ci-dessus, elle sera toujours visible directement via son URL, par exemple à Special:MySpecialPage. Afin de limiter réellement l'accès à votre page spéciale, vous devez appeler $this->checkPermissions() dans la méthode execute.

Si vous avez besoin d'un contrôle plus fin des autorisations, vous pouvez modifier $this->checkPermissions() et/ou ajouter la vérification des autorisations requises pour votre extension.

Désactiver Special:UserLogin et Special:UserLogout pages

Dans LocalSettings.php vous pouvez utiliser le SpecialPage_initList hook pour désinitialiser les pages spéciales embarquées non souhaitées. Voir « restreindre certaines pages spéciales » si vous avez besoin de débloquer conditionnellement des pages spéciales, par exemple pour certains groupes d'utilisateurs. Le message général « Vous avez demandé une page spéciale non valide.» s'affiche si les utilisateurs tentent d'accéder à ces pages spéciales non débloquées.

$wgHooks['SpecialPage_initList'][] = function ( &$list ) {
	unset( $list['Userlogout'] );
	unset( $list['Userlogin'] );
	return true;
};

Une approche différente serait d'utiliser le callback de DisabledSpecialPage. On peut préférer cette approche si vous ne faites que désactiver la page spéciale temporairement, car le message par défaut dans ce cas indiquera : « Cette page a été désactivée par un administrateur système. » au lieu de prétendre que la page n'existe pas du tout. Cela indique clairement que la page peut être activée utlérieurement.

$wgSpecialPages['Userlogout'] = DisabledSpecialPage::getCallback( 'Userlogout' );
$wgSpecialPages['Userlogin'] = DisabledSpecialPage::getCallback( 'Userlogin' );

Il est aussi possible d'ajouter une longue explication personnalisée donnant la raison de la désactivation de la page spéciale, en fournissant une clé de message au second argument de la procédure de callback. Pour faire cela, créez d'abord un message système « MediaWiki:Userlogout-disable-reason » et écrivez-y toutes les explications. Le message sera analysé sous un format bloc. Puis dans LocalSettings.php ajoutez :

$wgSpecialPages['Userlogout'] = DisabledSpecialPage::getCallback( 'Userlogout', 'Userlogout-disable-reason' );

Ajouter des journaux

Sur MediaWiki, toutes les actions des utilisateurs sur le wiki sont tracées pour la transparence et la collaboration. Voir Enregistrer dans Special:Log pour savoir comment le faire.

Modifier les groupes sur Special:Specialpages

Si vous êtes un développeur d’extensions, vous devez implémenter la méthode getGroupName() comme décrit dans la section du groupe des pages spéciales de cette page.

Depuis MediaWiki 1.21, le groupe des pages spéciales peut être réécrasé en modifiant un message système. Cette méthode n'est pas faite pour les développeurs d'extensions mais pour les administrateurs de site. Le nom du groupe doit être placé dans le message specialpages-specialpagegroup-<special page name>, où <special page name> est le nom canonique (en anglais) de la page spéciale en minuscules. Par exemple, si vous voulez définir le groupe dans lequel Special:MyLittlePage est affiché sur Special:Specialpages à MyLittleGroup, il vous suffit de créer MediaWiki:Specialpages-specialpagegroup-mylittlepage avec le contenu MyLittleGroup. Special:MyLittlePage apparaîtra ensuite dans le groupe MyLittleGroup, que vous pourrez nommer en MediaWiki:Specialpages-group-mylittlegroup.

Si vous voulez modifier le groupe des pages spéciales existantes, voyez Special:SpecialPages&uselang=qqx et utilisez ces noms au lieu de « mapetitepage ».

Omettre une page dans Special:Specialpages

Pour supprimer une page spéciale de l'ensemble des Special:Specialpages, passer false dans le troisième paramètre du constructeur parent de SpecialPage comme indiqué dans la section relative au constructeur de SpecialPage sur cette page. Si vous avez besoin d'une logique plus complexe pour déterminer si une page doit être listée ou pas, vous pouvez également redéfinir une fonction isListed(), mais utiliser le paramètre du constructeur est plus simple.

Obtenir la liste des pages spéciales avec leur alias sur un wiki

Utilisez simplement le module d’API « siteinfo » pour obtenir l’information du wiki comme par exemple /api.php?action=query&meta=siteinfo&siprop=specialpagealiases.

Voir aussi

HTMLForm – Tutoriel pour créer des cases à cocher, des zones de texte, des boutons radio, etc. à l'intérieur des pages spéciales