Handleiding:Speciale pagina's

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

Speciale pagina's zijn pagina's die door de software worden aangemaakt als er om het uitvoeren van een specifieke functie wordt gevraagd.

Een speciale pagina kan bijvoorbeeld alle pagina's weergeven met een of meer koppelingen naar een externe site of een formulier maken met door de gebruiker ingediende feedback.

Speciale pagina's bevinden zich in hun eigen namespace (Special:) en kunnen niet direct worden bewerkt zoals andere pagina's. Developers/nl kan ook nieuwe speciale pagina's maken.

Deze pagina's zijn standaard toegankelijk voor de gebruiker en worden over het algemeen weergegeven in de lijst met alle speciale pagina's op Special:SpecialPages. Sommige speciale pagina's zijn alleen toegankelijk voor gebruikers met bepaalde machtigingen en toegangen. Andere speciale pagina's verschijnen helemaal niet op de speciale paginalijst en worden alleen intern door de wiki gebruikt.

Algemene informatie

Alle ingebouwde speciale pagina's die bij MediaWiki worden geleverd, worden op SpecialSomename.php genoemd en bevinden zich in de map includes/specials. Speciale kernpagina's moeten worden geregistreerd in de kernlijst in includes/specialpage/SpecialPageFactory.php om door MediaWiki te worden geladen. Speciale pagina's die door externe ontwikkelaars zijn gemaakt, worden over het algemeen opgeslagen in de map extensions in hun eigen bestand of als onderdeel van een grotere extensie. Alle speciale pagina's erven van een class genaamd SpecialPage die is gedefinieerd in includes/specialpage/SpecialPage.php. Wanneer een nieuwe speciale pagina wordt gemaakt, kunnen de gebruikersrechten worden gedefinieerd die nodig zijn om toegang te krijgen tot de pagina. Deze rechten geven onder andere aan of de pagina op Special:SpecialPages wordt weergegeven en of de pagina op andere pagina's kan worden opgenomen.

Speciale pagina's hebben ook unieke namen die op een wiki kunnen worden aangepast. De algemene vorm is "Special:Pagename" waarbij zowel "Special" als "Pagename" aanpasbaar zijn. De Speciale pseudo namespace kan in andere talen worden vertaald. Deze vertaalde namespace kan worden geproduceerd met de wikitekst {{ns:special}}, op deze wiki met "Special". De naam van de speciale pagina kan ook opnieuw worden gedefinieerd in een systeembericht, voor de taal van de site, met de generieke naam van de speciale pagina als de ID.

Een speciale pagina kan al dan niet invoer toestaan. Met Special:Export kan een gebruiker bijvoorbeeld een specifieke pagina definiëren om te exporteren door Special:Export/Sun aan te roepen. Als de speciale pagina complexe invoer toestaat, worden aanvullende parameters verzonden naar de component query string van de URL voor verwerking, bijvoorbeeld https://www.mediawiki.org/w/index.php?title=Special:Recentchanges&days=3&limit=250.

  • Er zijn verschillende manieren om speciale pagina's te maken, maar de onderstaande wordt gebruikt door het grootste deel van de officiële extensions , en naleving van deze stijl wordt aanbevolen. Zorg er ook voor dat u een creditblok opneemt in de nieuwe speciale pagina voor 'specialpage'. Zie $wgExtensionCredits voor meer informatie.
  • Nadat u een nieuwe speciale pagina heeft gemaakt, moet u deze toevoegen aan Category:Special page extensions/nl , zodat andere mensen de pagina kunnen vinden.
  • Speciale pagina's kunnen niet worden opgenomen in frames, tenzij u $wgOut->allowClickjacking(); gebruikt;

Basissjabloon speciale pagina

Voor de meeste extensies voor een speciale pagina zijn er drie bestanden vereist:

  • een klein installatiebestand, dat elke keer wordt geladen wanneer MediaWiki wordt gestart.
  • bestand met de meeste code.
  • Lokalisatie bestand

MediaWiki codering conventies definiëren de drie bestanden zo:

  • MyExtension/extension.json - Het bestand voor het instellen.
  • MyExtension/includes/Special.php - De speciale pagina code.
  • i18n/*.json - De localisation file .

Zet alle bestanden in een nieuwe map in uw MediaWiki map extensions/

Noem de naam van het speciale pagina bestand na de extensie. Bijvoorbeeld, Extension:Gadgets bevat het bestand SpecialGadgets.php. Als uw extensie meer dan één speciale pagina gebruikt, heeft u meer namen nodig.

In onderstaand voorbeeld is de naam van de speciale pagina MyExtension.

Na het maken van de onderstaande bestanden, voeg de volgende regel toe aan LocalSettings.php, het schakelt de extensie in:

wfLoadExtension( 'MyExtension' );

Het bestand voor de configuratie

Voorbeeld van een installatiebestand voor 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.40.0",
		"platform": {
			"php": ">= 5.6"
		},
		"extensions": {
			"dependendExtension": "*"
		}
	}
}

Dit bestand registreert een aantal belangrijke en verplichte zaken:

  • de plaats van de class MediaWiki\Extension\MyExtension\Special
  • de plaats van de lokalisatie bestanden
  • de nieuwe speciale pagina en de bijbehorende class naam.
If you get the error InvalidArgumentException: Provided specification is not an array, it generally means that MediaWiki could not find the class specified in extension.json that implements your special page.

Het speciale pagina bestand

Het bestand (MyExtension/src/Special.php) moet een subclass van SpecialPage of een van de subclasses ervan bevatten. Dit bestand wordt automatisch geladen wanneer iemand de speciale pagina kiest. In het onderstaande voorbeeld wordt de subclass SpecialMyExtension geïmplementeerd.

U hebt de constructor __construct() nodig omdat de eerste parameter uw speciale pagina een naam geeft.

execute() is de belangrijkste functie die wordt aangeroepen wanneer een speciale pagina wordt geopend. Deze functie overschrijft,voor deze class, de functie SpecialPage::execute(). Het geeft de enkele parameter $par, de subpaginacomponent van de huidige titel. Als iemand bijvoorbeeld een link naar Special:MyExtension/blah volgt, bevat $par "blah".

U moet Wikitekst en HTML-uitvoer uitvoeren via $wgOut. Gebruik 'print' of 'echo' niet direct wanneer u binnen de gebruikersinterface van de wiki werkt.

Als u uw speciale pagina echter gebruikt als toegangspunt voor aangepaste XML- of binaire uitvoer, raadpleegt u Taking over output in your special page .

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

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

		# Haal aanvraaggegevens op van bijvoorbeeld:
		$param = $request->getText( 'param' );

		# Doe iets wat er moet worden gedaan
		# ...
		$wikitext = 'Hello world!';
		$output->addWikiTextAsInterface( $wikitext );
	}
}

Het lokalisatiebestand

Lees voor hoe het vertaald te krijgen: Help:Systeembericht .

Alle speciale pagina's geven een titel op, zoals 'My Extension'.

  • De titel wordt gebruikt in de ‎<title> en ‎<h1> elementen van de pagina van de extensie en op Special:SpecialPages.
  • Het kan van alles zijn, maar moet de speciale pagina en extensie beschrijven.
  • Het wordt opgegeven via een bericht. De structuur van het bericht is een sleutel-waardepaar. De sleutel, 'myextension', moet uit allemaal kleine letters bestaan.

Een voorbeeld van een lokalisatiebestand in $i 18n:

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

In i18n/qqq.json, de bericht documentatie:

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

Houd er rekening mee dat id's niet met een hoofdletter mogen beginnen en dat een spatie in de id als onderstrepingsteken in de code moet worden geschreven.

Het bericht samenvatting is optioneel. Het wordt automatisch gemaakt door de bovenliggende class en bovenaan de speciale pagina weergegeven, meestal voor een beknopte beschrijving van wat de gebruiker ermee kan doen. Als u de inhoud niet definieert, wordt deze alleen gebruikt wanneer wikibeheerders deze op de wiki aanpassen.

Het aliassen bestand

U kunt de naam van de speciale pagina ook internationaliseren door er aliassen voor te maken. In het onderstaande voorbeeld wordt het bestand "MyExtension.i18n.alias.php" gebruikt. In dit voorbeeld registreert de speciale pagina MyExtension een alias zodat de pagina toegankelijk wordt op .../Special:My Extension en .../Spezial:Meine_Erweiterung in het Duits.

Voeg uw aliasbestand toe aan extension.json:

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

Voeg speciale pagina-aliassen toe aan MyExtension.i18n.alias.php:

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

$specialPageAliases = [];

/** English
 * @author <uw gebruikersnaam>
 */
$specialPageAliases['en'] = [
	'MyExtension' => [ 'MyExtension', 'My Extension' ],
];

/** Deutsch
 * @author <uw gebruikersnaam>
 */
$specialPageAliases['de'] = [
	'MyExtension' => [ 'MeineErweiterung', 'Meine Erweiterung' ],
];

Nogmaals, u moet een spatie in de ID en een onderstrepingsteken in de code schrijven.

Voor de paginakoptekst en koppeling gelden de gebruikelijke regels voor paginanamen.

Als $wgCapitalLinks waar is, wordt een kleine letter omgezet in hoofdletters en wordt een onderstrepingsteken weergegeven als spatie.

In plaats van het bovenstaande kunnen we bijvoorbeeld 'my_extension' => 'My extension' gebruiken, ervan uitgaande dat we de extensie consequent elders als my_extension hebben geïdentificeerd.

Merk op dat in de associatieve array voor de Engelse taal, de tekenreeks die onze SpecialPage identificeert (MyExtension in het voorbeeld) ook een geldige titel is.

Merk ook op dat het eerste element van $specialPageAliases['en']['MyExtension'] hetzelfde moet zijn als de 'MyExtension'! Anders wordt de pagina niet weergegeven door Special:Specialpages.

Speciale pagina groep

U kunt instellen onder welke groep uw speciale pagina op Special:SpecialPages wordt weergegeven door SpecialPage::getGroupName() in uw subclass te overschrijven.

    /**
     * Het bovenliggende gedeelte overschrijven om in te stellen waar de speciale pagina wordt weergegeven op Special:SpecialPages
     * 'other' is de standaardinstelling. Als dat is wat u wilt, hoeft u niet te overschrijven.
     * Geef 'media' op om het interfacebericht <code>specialpages-group-media</code> te gebruiken, wat zich vertaalt naar iets als 'Mediarapporten en uploads' in het Nederlands;
     * 
     * @return string
     */
    function getGroupName() {
        return 'media';
    }

Enkele veel voorkomende waarden zijn 'login', 'maintenance', 'media', 'other', 'pagetools', 'redirects', 'users'. U kunt de geaccepteerde waarden op Special:AllMessages zien (zoek op specialpages-group) of door de wiki bladeren met behulp van de pseudotaal 'qqx' door naar Special:SpecialPages?uselang=qqx) te gaan en naar de koppen te kijken. Geef het woord 'media' op om het interfacebericht 'specialpages-group-media' te gebruiken.

Als uw speciale pagina niet in een van de vooraf geconfigureerde koppen past, kunt u een nieuwe kop toevoegen door deze toe te voegen aan uw lokalisatiebestand, zie het lokalisatiebestand).

De standaardpaginagroepen die bij MediaWiki worden geleverd, worden weergegeven in het lokalisatiebestand. De Engelse berichten staan bijvoorbeeld in languages/i18n/en.json en beginnen met specialpages-group-. Als u uw speciale pagina onder users wilt categoriseren, wordt het bericht specialpages-group-users. De waarde voor deze sleutel is de tekst die wordt weergegeven als de naam van die categorie, bijvoorbeeld Users and rights

Als uw speciale pagina niet onder een van de bestaande categorieën lijkt te passen, kunt u altijd een nieuwe maken. In het lokalisatiebestand van uw extensie voegt u eenvoudig een nieuwe sleutel in het array messages in. In dit voorbeeld definiëren we de groep 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"
}

Ervan uitgaande dat u de returnwaarde voor de methode SpecialPage::getGroupName() instelt als gamification in uw definitie van de classes, laadt u Special:SpecialPages opnieuw om uw nieuwe categorie te zien.

Andere belangrijke bestanden

SpecialPage.php

Constructor

U kunt de constructeur overload doen om uw eigen gegevens te initialiseren, maar de belangrijkste reden waarom u dat wilt doen is om het gedrag van de class SpecialPage zelf te veranderen. Wanneer u de basis-class constructor uit uw child-class aanroept, zijn de volgende parameters beschikbaar:

function __construct( $name = '', $restriction = '', $listed = true );
  • string $name Naam van de speciale pagina, zoals in links en URL's te zien
  • string $restriction User right is vereist, bijvoorbeeld "block" of " delete"; zie ook paginatoegang beperken
  • boolean $listed Of de pagina is opgenomen in de lijst Special:Specialpages

SpecialPage->setHeaders()

Hiermee wordt het object OutputPage $wgOut geïnitieerd met de naam en beschrijving van uw speciale pagina. Het moet altijd worden aangeroepen vanuit uw execute() methode.

SpecialPage->getOutput()

Deze methode geeft een object OutputPage terug dat, zoals hieronder beschreven, kan worden benaderd. Gebruik, zoals in de voorbeeldcode,

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

in plaats van de ontraden globale variabele $wgOut

SpecialPage->getRequest()

Deze methode geeft een object WebRequest terug dat, zoals hieronder beschreven, kan worden benaderd. Gebruik, zoals in de voorbeeldcode,

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

in plaats van de ontraden globale variabele $wgRequest

SpecialPage->including()

Sommige speciale pagina's kunnen worden toegevoegd (included) vanuit een andere pagina. Als u bijvoorbeeld {{Special:RecentChanges}} toevoegt aan de wiki-tekst van een pagina, wordt er een lijst van recente wijzigingen ingevoegd binnen de bestaande inhoud van de pagina.

Het opnemen van een speciale pagina van een andere webpagina is alleen mogelijk als u de pagina als inclusief in de constructor hebt verklaard. Dit kan u doen door het volgende toe te voegen in de methode __construct() na de initialisatie van de parent-class:

$this->mIncludable = true;

U kunt uw speciale pagina-class ook definiëren als een uitbreiding van de class IncludableSpecialPage.

De functie SpecialPage->including() geeft een boolean-waarde terug die u de context aangeeft waarin de speciale pagina wordt opgeroepen: false als het een aparte webpagina is en true als het wordt gedaan vanuit een andere webpagina. Meestal wilt u de presentatie wat kleiner maken als de pagina wordt opgenomen.

SpecialPage->execute()

Dit is de functie die uw child class met overload gebruikt moet worden. Het geeft een enkele parameter door, meestal cryptisch aangeduid als $par (kort voor $parameter, omdat het de parameter is die de gebruikers kunnen doorgeven aan uw speciale pagina). Deze parameter is de subpaginacomponent van de huidige titel. Als iemand bijvoorbeeld een link naar Special:MyExtension/blah volgt, bevat $par "blah".

Helppagina
MediaWiki-versie:
1.25

Het is handig om helppagina's op MediaWiki.org toe te voegen, waar ze vertaalbaar zullen zijn. Om ervoor te zorgen dat gebruikers uw hulppagina vinden, is het raadzaam en heel eenvoudig voor uw speciale pagina om de betreffende hulppagina te koppelen:

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

OutputPage.php

OutputPage.php bevat de definitie van classes voor objecten van het type OutputPage. U kunt een object van deze class van uw SpecialPage krijgen met behulp van

$output = $this->getOutput();

De naam van de variabele $output is natuurlijk willekeurig. Hoe u het ook noemt, dit is de variabele die u het meest gebruikt, omdat het de manier is om uitvoer naar de browser te sturen (Gebruik dus niet echo of print). Als u het ergens wilt gebruiken, maak uw variabele dan globaal:

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

Als u wilt, kunt u meerdere OutputPage-objecten op verschillende manieren maken in uw extensie SpecialPage. Ze zullen de uitvoer toevoegen in de volgorde waarin ze worden uitgevoerd.

U kunt de class OutputPage inspecteren door includes/OutputPage.php te bekijken (eigenlijk, deze kunnen allemaal worden gecontroleerd), maar er zijn een paar methoden die u zeker moet kennen.

OutputPage->addHTML()

In wezen de snelle en vuile vervanging van echo. Het neemt de uitvoer en voegt het toe aan de buffer. In de onderstaande actie, als $action gebruikersgegevens bevat, kan het gemakkelijk XSS, kwaadaardige dingen of de rommel van Satan bevatten. U kunt beter gebruik maken van escape (zoals met de php functie htmlentities) of de XML-builders class om betrouwbare output te maken.

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

OutputPage->addWikiText()

Voor de meeste uitvoer, moet u deze functie gebruiken. Het is een soort zwarte doos: Wikitext in, HTML uit, en er gebeurt een hele hoop geheime code tussenin.

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

Het is opmerkelijk dat de parser uw stukken ziet als samenhangende geheel en paragraaf. Dat is...

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

Het zal drie lijsten met elk een item uitvoeren, wat waarschijnlijk niet zo bedoeld was.

  Waarschuwing: Als uw speciale pagina bedoeld is om in andere pagina's te worden opgenomen, moet u waarschijnlijk geen addWikiText() gebruiken (of een andere functie die de parser aanroept, behalve voor berichtgerelateerde functies die parsen ($this->msg()) die goed zijn om op moderne versies van MediaWiki te roepen). Vanwege een bug in MediaWiki (phab:T18129), zal een speciale pagina die is opgenomen, elke opname verknallen voordat deze op dezelfde pagina is opgenomen, met teksten als UNIQ10842e596cbb71da.

Let echter op, als u gewoon een systeembericht wilt toevoegen en het als geparseerde wikitext wilt behandelen, kunt u code gebruiken zoals $this->getOutput()->addHtml( $this->msg( 'key-of-message' )->parse() ). Dit zal niet het probleem hebben met de hierboven genoemde gebouwde parser aanroepen.

Tijdelijke oplossing #1

Belangrijk: deze tijdelijke oplossingen zijn alleen nodig als u een transcludable speciale pagina maakt. Normale speciale pagina's hebben deze niet nodig.

Als tijdelijke oplossing kunt u uw extensies Wikitext naar HTML laten omzetten met behulp van een apart Parser-object en vervolgens addHTML(). gebruiken Voorbeeld:

$wgOut->addHTML( $this->sandboxParse( "Here's some '''formatted''' text." ) );
# Als dit in dezelfde class zit als de rest van uw code van de speciale pagina.
function sandboxParse( $wikiText ) {
	$myParser = new Parser();
        $user = $this->getUser();
        $title = self::getTitleFor('YourCanonicalSpecialPageName');
	$myParserOptions = ParserOptions::newFromUser( $user );
	$result = $myParser->parse( $wikiText, $title, $myParserOptions );
	return $result->getText();
}

Tijdelijke oplossing #2

Ik heb het bovenstaande geprobeerd en heb ontdekt dat hetzelfde probleem nu van toepassing is op alle tags in de transcluded tekst. Dit zal geen probleem zijn voor veel extensies, maar de extensie die ik schreef was bedoeld om wikitext van een andere pagina te laten zien als onderdeel van de functionaliteit, dus was het hier een probleem.

Het proces voor het analyseren van een pagina die een speciale pagina omvat lijkt dit te zijn:

  1. Vervang {{Special:MyExtension}} met een UNIQ-QINU marker (omdat verwacht wordt dat de uitvoer van SpecialPage goede HTML is voor uitvoer)
  2. Vervang alle tags met QINU markers zoals hierboven
  3. Al het andere van wiki-tekst naar HTML parsen
  4. Vervang alle QINU markers met hun respectieve opgeslagen waarden, in één verwerking

Het proces voor het analyseren van een pagina die geen speciale pagina omvat lijkt dit te zijn:

  1. Vervang {{:Normal Article Name}} of {{Template Name}} met de inhoud van de omvatte pagina (omdat die getransclude pagina's niet verwerkte wikitext bevatten)
  2. Vervang alle tags met QINU markers zoals hierboven
  3. Al het andere van wiki-tekst naar HTML parsen
  4. Vervang alle QINU markers met hun respectieve opgeslagen waarden, in één verwerking

Het probleem is blijkbaar dat in het eerdere geval het parsen van de wiki-tekst van de SpecialPage de laatste QINU-decodingsstap ontbreekt (waarom?), dus alle QINU markers zijn ongecodeerd gelaten. (Dit kan een overblijfsel zijn van het gebruik van dezelfde syntaxis om transclusie van een wikitekstpagina op te roepen, die gewoon rechtstreeks in de wikitekstinhoud van de hostpagina wordt geplakt en geparseerd, zoals wordt gebruikt om transclusie van een SpecialPage aan te roepen, die helemaal niet mag worden geparseerd. Waar de code ook is die beslist "wacht, dit is een speciale pagina -- vervang deze door een QINU", het zou de extra unstripGeneral moeten doen voordat de QINU-substitutie wordt uitgevoerd.)


Dus ik deed het volgende -- na deze regel:

$htOut = $wgParser->recursiveTagParse( $iText );

...Ik heb deze regels toegevoegd (de tweede is alleen omdat de functiedefinitie van de eerste het aanbeveelt):

$htOut = $wgParser->mStripState->unstripGeneral( $htOut );
$htOut = $wgParser->mStripState->unstripNoWiki( $htOut );

Omdat ik dit nu heb gedocumenteerd, zal ik er natuurlijk een fout in vinden en me echt dom voelen... Maar zolang het werkt, moest ik het hier documenteren. (Het is ook belangrijk om het probleem met de tussenoplossing #1 op te merken.) Ik heb dit ook alleen getest met MediaWiki 1.10.1. Het probleem bestaat nog steeds onder MW 1.14, deze oplossing kan daar wel of niet werken. --Woozle 18:26, 9 April 2009 (UTC)

OutputPage->showErrorPage()

Er wordt een foutpagina weergegeven. De argumenten $codetile en $msg geven keys in $this->msg(), geen tekst. Een voorbeeldː

$output->showErrorPage( 'error', 'badarticleerror' );
  • 'error' verwijst naar de tekst "Fout".
  • 'badarticleerror' verwijst naar de tekst "Deze handeling kan niet op deze pagina worden verricht.".

U kunt ook berichtobjecten specificeren of parameters toevoegen:

$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

De class WebRequest wordt gebruikt om informatie te verkrijgen uit de GET- en POST-arrays. Het wordt aanbevolen dit te gebruiken boven direct toegang tot de superglobalen. Het object WebRequest is toegankelijk voor extensies met behulp van de RequestContext .

Database.php

MediaWiki heeft een heleboel functies en wrappers voor interactie met de database, met behulp van de class \Wikimedia\Rdbms\Database. Het heeft ook een interessant systeem voor belastingbalans. Het wordt aanbevolen dat u deze wrappers gebruikt. Kijk naar Database.php voor een volledige lijst van al deze functies, omdat deze documenten u alleen vertellen over de niet-duidelijke waarschuwingen. Zie Handboek:Database toegang .

User.php

De class User is een weergave van de gebruikers op het systeem. SpecialPage->getUser() moet worden gebruikt om een object User te verkrijgen voor de nu ingelogde gebruiker. Het gebruik van de global $wgUser wordt ontraden

Title.php

Titel staat voor de naam van een pagina in de wiki. Dit is nuttig omdat MediaWiki allerlei leuke escapes en speciale case logica doet bij pagina-namen, dus in plaats van uw eigen titel om te zetten naar URL-functie, maakt u een titel object met uw pagina-naam, en gebruikt dan getLocalURL() om een URL naar die pagina te krijgen.

Om een titel voor uw speciale pagina te krijgen van buiten class speciale pagina, kunt u SpecialPage::getTitleFor( 'YourCanonicalSpecialPageName' ) gebruiken. Het geeft u een vertaalde titel in de taal van de wiki.

Aangepaste speciale pagina's

Er zijn verschillende manieren om uw eigen speciale pagina's te maken die niet in MediaWiki zijn gebundeld:

  • Een methode is het installeren van een extensie die een formulier genereert om een artikel te maken of te bewerken. Een lijst met beschikbare extensies is te vinden op Category:Special page extensions/nl .
  • U kunt ook een extensie schrijven dat uw eigen speciale pagina biedt. Het schrijven van uw eigen extensie vereist coderingskunst en comfort met objectgericht ontwerp en databases is ook handig. U moet ook weten hoe u code gebruikt om MediaWiki-artikelen te maken en te bewerken. Voor meer informatie, zie deze discussie.
  • U kunt ook een aangepaste pagina weergeven via JavaScript, in plaats van de standaardfoutmelding "Onbekende speciale pagina" (of de melding "Deze pagina is opzettelijk leeg gelaten", als u een subpagina van Special:BlankPage gebruikt). In MediaWiki:Common.js, controle voor wgPageName , verbergt u de MediaWiki-gegenereerde inhoud (voeg gewoon CSS {visibility:hidden;} toe) en injecteert u aangepaste HTML (innerHTML) in de document.getElementById('bodyContent') of document.getElementById('mw_contentholder'). Zie bijvoorbeeld deze pagina Recente wijzigingen van gebruiker Krinkle.

Veelgestelde vragen

Een titel van de extensie instellen

MediaWiki geeft de titel van de extensie niet aan, wat de taak van de ontwikkelaar is. Het zal de naam van de extensie zoeken wanneer Special:Specialpages wordt aangeroepen of de speciale pagina wordt geladen. In de sectie function execute( $par ), gebruik OutputPage-methoden om de extensie een titel te geven, zoals: $this->getOutput()->setPageTitle("your title");

De plaats waar de extensie kan worden gevonden (zoals gespecificeerd door wat wordt doorgestuurd in de SpecialPage constructor) is de key - "behalve" dat het niet in hoofdletter is geschreven vanwege getDescription(), de intern gebruikte functie die de titel (of, wat ze beschrijving noemen) van de speciale pagina, strtolower de naam. De key van "ThisIsAcoolsSpecialPage" zou zijn "thisisacoolspecialpage".

Theoretisch kan getDescription overschreven worden om te voorkomen dat er interactie is met de berichtencache, maar, zoals de broncode zegt: "Afgeleide classes kunnen dit overschrijven, maar meestal is het gemakkelijker om het standaardgedrag te behouden". Bovendien voorkomt dit dat de MediaWiki-namespace het bericht overschrijft, zoals hieronder.

De extensienaam vertalen

Dus u heeft net een nieuwe MediaWiki-extensie geïnstalleerd en u realiseert u: "Oh nee, mijn wiki is in het Frans, maar de pagina verschijnt in het Engels!" De meeste mensen zouden het niet willen, maar het is eigenlijk een vrij eenvoudige taak om het te herstellen (zolang de ontwikkelaar de methode heeft gebruikt die op deze pagina wordt beschreven). Geen 'handige' improvisatie in de broncode. Laten we zeggen dat de naam van de pagina DirtyPages is en de naam komt naar "List of Dirty Pages" maar u wilt dat het (en sorry mijn voor Frans) "Liste de Pages Sales" is. Het is zo simpel als dit:

  1. Ga naar MediaWiki:DirtyPages, deze pagina bestaat misschien niet, maar bewerk het toch
  2. Voeg "Liste de Pages Sales" toe en sla het op

En voilà, de verandering wordt toegepast.

Dit is ook handig om de titel van uw wiki in uw taal aan te passen: bijvoorbeeld, de ontwikkelaar noemde het "List of Dirty Pages" maar u houdt niet van die naam, dus u noemt het "List of Pages needing Cleanup". Bekijk Special:Allmessages voor meer uitleg.

Als uw extensie een groot tekstblok heeft dat verandert, zoals een waarschuwing, voer de tekst dan niet direct uit. Voeg het in plaats daarvan toe aan de berichtencache en wanneer het tijd is om de tekst in uw code uit te voeren, doet u:

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

Dan kan ook dit bericht op MediaWiki:Dirtypageshelp worden aangepast.

Zie ook Help:Systeembericht .

Beperking van toegang tot pagina's

Uw speciale pagina niet weergeven op Special:SpecialPages

Soms wilt u de zichtbaarheid van een speciale pagina beperken door het te verwijderen uit Special:SpecialPages en het alleen zichtbaar te maken voor gebruikers met een bepaald recht. Dit kunt u doen in de constructor door een $restrictionparameter door te geven; bijvoorbeeld "editinterface", een recht dat alleen standaard aan sysops wordt toegewezen; zie deze handleiding voor andere beschikbare gebruikersrechten.

function __construct() {
	parent::__construct( 'MyExtension', 'editinterface' ); // beperkt tot sysops
}

Of u kunt uw eigen recht in het setupbestand maken en het toewijzen aan sysops, bijvoorbeeld:

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

en dan de constructor met uw rechten aanroepen:

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

Toegang tot uw speciale pagina voorkomen

Zelfs als u uw pagina in de constructor beperkt, zoals hierboven vermeld, zal deze nog steeds direct te bekijken zijn via de URL, bijvoorbeeld met Special:MySpecialPage. Om de toegang tot uw SpecialPage te beperken, moet u $this->checkPermissions() aanroepen in de methode execute.

Als u meer controle over de toestemming nodig heeft, kunt u $this->checkPermissions() overschrijven en/of de controle toevoegen die nodig is voor uw extensie.

Uitzetten pagina's Special:UserLogin en Special:UserLogout

In LocalSettings.php kunt u de SpecialPage_initList hook gebruiken om ongewenste ingebouwde speciale pagina's te onderdrukken. Zie "making a few SpecialPages restricted" als u een conditionele uitschakeling van bepaalde speciale pagina's nodig heeft bijvoorbeeld voor bepaalde gebruikersgroepen. Het algemene bericht U hebt een ongeldige speciale pagina aangevraagd wordt weergegeven als gebruikers proberen toegang te krijgen tot dergelijke onderdrukte speciale pagina's.

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

Een andere benadering zou zijn om de callback van DisabledSpecialPage te gebruiken. Deze benadering kan voorkeur krijgen als u de speciale pagina "tijdelijk" alleen uitschakelt, omdat het standaardbericht in dit geval zou zeggen: "Deze pagina is uitgeschakeld door een systeembeheerder." in plaats van te doen alsof de pagina helemaal niet bestaat. Dit geeft een duidelijke hint dat de pagina later mogelijk geactiveerd gaat worden.

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

Het is ook mogelijk om een aangepaste lange verklaring toe te voegen van waarom die speciale pagina is uitgeschakeld, door een berichtsleutel te geven als het tweede argument van de callback. Om dit te doen, moet u eerst een systeembericht "MediaWiki:Userlogout-disable-reason" maken en daar alle uitleg schrijven. Het bericht wordt in blokformaat geanalyseerd. Voeg dan in LocalSettings.php toe:

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

Logs toevoegen

in Mediawiki worden alle gebruikersactie op een wiki gevolgd tbv transparantie en samenwerking. Bekijk ̯Manual:Logging to Special:Log hoe dat gedaan kan worden.

De groepen op Special:Specialpages veranderen

Als u een ontwikkelaar van extensies bent, moet u de methode getGroupName() implementeren zoals beschreven in de sectie Speciale paginagroep van deze pagina.

Sinds MediaWiki 1.21, kan de speciale paginagroep worden overschreven door het bewerken van een systeembericht. Deze methode is niet bedoeld voor gebruik door ontwikkelaars, maar voor gebruik door site-beheerders. De groepsnaam moet worden geplaatst in het bericht specialpages-specialpagegroup-<special page name>, waar <special page name> de canonische naam (in het Engels) van de speciale pagina in kleine letters is. Als u bijvoorbeeld de groep wilt instellen waaronder "Special:MyLittlePage" wordt weergegeven op Special:Specialpages als "MyLittleGroup", moet u gewoon "MediaWiki:Specialpages-specialpagesgroup-mylittlepage" de inhoud "MyLittleGroup" geven. "Special:MyLittlePage" wordt vervolgens weergegeven onder de groep "MyLittleGroup", die u kunt noemen onder "MediaWiki:Specialpages-group-mylittlegroup".
Als u de groep van bestaande speciale pagina's wilt wijzigen, kijk dan naar Special:SpecialPages&uselang=qqx en gebruik die namen in plaats van "mylittlepage".

Het verwijderen van de pagina uit Special:Specialpages

Om een speciale pagina uit de Special:Specialpages volledig te verwijderen, geef een false als derde parameter door aan de SpecialPage constructor van de parent, zoals beschreven in de sectie SpecialPage Constructor van deze pagina. Als u meer ingewikkelde logica nodig hebt om te bepalen of de pagina moet worden vermeld of niet, kunt u ook de functie isListed() overschrijven, maar het gebruik van de constructor-parameter is eenvoudiger.

Het krijgen van een lijst met speciale pagina's en hun aliassen op een wiki

Gebruik gewoon de API-module "siteinfo" om de informatie uit de wiki te halen zoals bijvoorbeeld /api.php?action=query&meta=siteinfo&siprop=specialpagealiases.

Zie ook

  • HTMLForm – Tutorial over het maken van checkboxes, text areas, radioknoppen, enz. op speciale pagina's