Module:Wd
![]() | This module is subject to page protection. It is a highly visible module in use by a very large number of pages, or is substituted very frequently. Because vandalism or mistakes would affect many pages, and even trivial editing might cause substantial load on the servers, it is protected from editing. |
![]() | Ang Lua module na ito ay ginagamit ng nasa 1,740,000 pahina, o halos 706% ng lahat pahina. Para makaiwas sa mga problema at load sa server, pakisubok muna ang anumang pagbabago sa subpahina ng module na /burador o /pagsubok, o sa sarili mong module sandbox. Maaaring idagdag ang mga pagbabagong ito sa pahina sa tulong ng ibang editor. Pag-usapan muna ang mga balak na pagbabago sa pahina ng usapan bago gawin ito. |
![]() | You might want to use one of the user-friendly wrapper templates {{Wikidata}} and {{WikidataOI}} instead of invoking this module directly. |
Related pages |
---|
This module is intended to fetch data from Wikidata with or without a link to the connected Wikipedia article and with many other features.
Usage
{{#invoke:wd|command1|flag1a|flag1b|flag1c|command2|flag2a|flag2b|flag2c|flag0a|flag0b|flag0c|arg1|arg2|arg3}}
Commands
The commands (command1
, command2
, ...) determine what kind of values are returned. One call can only contain commands from a single class, except that the main class is always used together with one other class.
Claim class
The claim class commands can be combined, meaning that multiple commands of different types from this class can be given at one time.
Combine multiple commands into one call to this module, instead of making multiple calls to this module with one command each, to be sure that all the returned pieces of information belong to each other.
Type | Command | Returns | Basic usage | Description |
---|---|---|---|---|
I | property
|
first match[a] | {{#invoke:wd|property|P1}}
|
Returns the requested property – or list of properties – from the current item-entity or from a given entity. |
properties
|
all matches | {{#invoke:wd|properties|P1}}
| ||
II | qualifier
|
first match[a] | {{#invoke:wd|qualifier|P1|P2}}
|
Returns the requested qualifier – or list of qualifiers – from the given property of the current item-entity or of a given entity.
Unlike the other claim class commands, this command can be given multiple times to retrieve different qualifiers in one call. |
qualifiers
|
all matches | {{#invoke:wd|qualifiers|P1|P2}}
| ||
III | reference
|
first match[a] | {{#invoke:wd|reference|P1}}
|
Returns a reference – or list of references – from the given property of the current item-entity or of a given entity.[b] |
references
|
all matches | {{#invoke:wd|references|P1}}
| ||
|
General class
The general class commands cannot be combined.
Type | Command | Returns | Basic usage | Description |
---|---|---|---|---|
I | label
|
{{#invoke:wd|label}}
|
Returns the label of the current item-entity or of a given entity if present. | |
II | title
|
{{#invoke:wd|title}}
|
Returns the title of the page linked to the current item-entity or to a given item-entity if such page exists. | |
III | description
|
{{#invoke:wd|description}}
|
Returns the description of the current item-entity or of a given entity if present. | |
IV | alias
|
first match[a] | {{#invoke:wd|alias}}
|
Returns an alias – or list of aliases – of the current item-entity or of a given entity if present. |
aliases
|
all matches | {{#invoke:wd|aliases}}
| ||
V | badge
|
first match[a] | {{#invoke:wd|badge}}
|
Returns a badge – or list of badges – for the page linked to the current item-entity or to a given item-entity if such page exists. |
badges
|
all matches | {{#invoke:wd|badges}}
| ||
Main class
The main
command is always used alone and does not take any flags or arguments. It allows parent templates to pass on their parameters in the form of commands to this module.
Command | Basic usage | Description |
---|---|---|
main |
{{#invoke:wd|main}} |
Intended for use by wrapper templates (around this module) to invoke one or more of the above commands, returning their respective output.
The parameters passed to the wrapper template are the ones that will be used by the module, e.g. Therefore, any parameters set by the wrapper template itself will be discarded, e.g. |
Flags
The following (optional) flags are available which can be used to alter this module's behaviour. They must be given after the (first) command and before the other arguments. For convenience, empty flags (i.e. ||
) are allowed and will simply be ignored.
Command flags
These flags (flag1*
, flag2*
, ...) apply to the command that precedes them directly.
Flag | Description |
---|---|
linked
|
Creates a link to the Wikipedia article that is connected to the property or qualifier if it exists. Also links units of measurement that may be appended to values.
If this parameter is omitted, then the plain property or qualifier value will be returned. |
short
|
[EXPENSIVE] Returns the maikling pangalan (P1813) of any entity returned if they have one attached. If that is not the case, then the default behaviour of returning the entity's label will occur.
|
raw
|
Returns the raw value if applicable.
If this flag is used with item or property datatypes, then this will return the Q-identifier or P-identifier. For quantity datatypes, this flag will strip off any units of measurement, unless the If this flag is used with time datatypes, then the returned date will be in the format of If it is used with globe coordinate datatypes, then it replaces the various symbols with forward slashes in the returned value (e.g. |
multilanguage
|
Returns monolingual text values in any available language, not just the current wiki's language. |
unit
|
Returns only the unit of measurement for quantity datatypes. |
Configuration flags
These flags (flag0*
) are general configuration flags and can be given anywhere after the first command (but before the other arguments).
Flag | Command class | Description | |
---|---|---|---|
Combination of: | preferred
|
claim | Sets a rank constraint for the selected claim(s).
The first three set the ranks for which claim(s) will be selected. They can optionally be followed by a If the The default is Output is always sorted from highest rank to lowest (regardless of any of these flags being set). |
normal
| |||
deprecated
| |||
best
| |||
Combination of: | future
|
claim | Sets a time constraint for the selected claim(s). Uses the claims' qualifiers of araw ng simula (P580) and araw ng katapusan (P582) to determine if the claim is valid for the selected time period(s).
The default is |
current
| |||
former
| |||
mdy
|
claim | Returns date values in month-day-year order instead of day-month-year order. | |
single
|
claim | Returns only a single claim instead of multiple (if multiple claims match). Has no effect if the property /properties command is given, in which case this flag would be redundant.
| |
sourced
|
claim | Only returns claims that have at least one valid reference. | |
One of: | edit
|
claim, general | Adds a clickable icon after the output that may be used by readers to edit the returned claim on Wikidata.
If |
edit@end
|
Arguments
The arguments determine the sources from which all the returned values are fetched.
Positional arguments
The following table shows the available positional arguments (arg*
) in their fixed order. For each command, the applicable set of arguments is marked. If multiple commands are given, then the applicable set is the union of the individual sets. For instance, if the commands properties
and qualifiers
have been given, then at least both the arguments property_id
and qualifier_id
should be given as well.
More than one qualifier
/qualifiers
command can be given. The order in which these commands with their flags are given matches the order in which the respective qualifier_id
arguments are given.
(required) | (optional) | (optional) | (required) | (optional) | (required) | (required) | |||
{{#invoke:wd
|
commands
|
flags
|
entity_id
|
property_id
|
raw_value
|
qualifier_id
|
qualifier_id
|
}}
| |
---|---|---|---|---|---|---|---|---|---|
label , title ,description ,alias /aliases ,badge /badges
|
|||||||||
property /properties
|
|||||||||
reference /references
|
|||||||||
qualifier /qualifiers
|
|||||||||
qualifier /qualifiers (optional 2nd, 3rd, etc.)
| |||||||||
Below follows a description of all positional arguments.
Argument | Description |
---|---|
entity_id
(optional) |
[EXPENSIVE] Q-identifier of the item-entity to be accessed (e.g. Q55 ), or P-identifier (or an available alias) of the property-entity to be accessed preceded by the Property: prefix (e.g. Property:P38 ).
In case of the general class commands, the If this parameter is omitted, then the item-entity connected to the current page will be used (except when |
property_id
|
P-identifier (or an available alias) of the property within the entity to be accessed, without the Property: prefix (e.g. P35 ).
|
raw_value
(optional) |
Either the Q-identifier equal to the property value (e.g. Q29574 ) or a literal value (i.e. string or quantity etc., no entity label) equal to the raw property value of the particular claim to be accessed.
Dates as literal values must be formatted Globe coordinates as literal values must be formatted with forward slashes (i.e. The special type 'no value' can be given by entering the empty string (i.e. To get a literal vertical bar If this parameter is omitted, then all claims (matching any other constraints) within the property will be accessed. |
qualifier_id
|
P-identifier (or an available alias) of the qualifier within the entity to be accessed, without the Property: prefix (e.g. P580 ).
|
Named arguments
Below follows a description of all named arguments, which are name-value pairs (i.e. |name=value
). These are all optional and can be given anywhere after the first command.
Argument | Description |
---|---|
eid=
|
[EXPENSIVE] This argument offers the same functionality as the positional argument entity_id (e.g. |eid=Q55 ), with one difference: if the argument is given but its value is left empty (i.e. |eid= ), then no entity is accessed at all instead of the item-entity connected to the current page. This is useful in some cases where a variable entity-ID is expected, but where the item-entity connected to the current page should not be accessed as the default.
Also, the This argument only has effect if the positional argument |
<qualifier>=
|
The <qualifier> is a placeholder for a set of arguments that determine which claims should be accessed based on qualifier value, analogous to the pair of positional arguments property_id and raw_value that determine access based on property value.
As such, Example: Multiple arguments of this type can be given to match multiple qualifier values simultaneously for each claim. |
Property aliases
Property aliases are other names for P-identifiers that can be used instead. The following property aliases (which are case-sensitive) are currently available:
Alias | translates to |
P-identifier |
---|---|---|
coord | → | P625 |
image | → | P18 |
author | → | P50 |
publisher | → | P123 |
importedFrom | → | P143 |
statedIn | → | P248 |
pages | → | P304 |
language | → | P407 |
publicationDate | → | P577 |
startTime | → | P580 |
endTime | → | P582 |
chapter | → | P792 |
retrieved | → | P813 |
referenceURL | → | P854 |
sectionVerseOrParagraph | → | P958 |
archiveURL | → | P1065 |
title | → | P1476 |
formatterURL | → | P1630 |
quote | → | P1683 |
shortName | → | P1813 |
archiveDate | → | P2960 |
inferredFrom | → | P3452 |
typeOfReference | → | P3865 |
column | → | P3903 |
Advanced usage
The layout of the output from (a combination of) commands that have both a singular and a plural form (e.g. property
/properties
) can be customized by using a number of named flags, which are name-value pairs (i.e. |flag=value
), that can be given anywhere after the first command. The table below shows the available named flags.
To insert a space at the beginning or end of a value
, use an underscore _
. To get a literal underscore, escape it by placing a backslash \
directly in front of it (i.e. \_
); the same holds for a literal backslash (i.e. \\
). To get a literal vertical bar |
, use {{!}}
or |
.
Named flag | Default value | Default condition | Description | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
format=
|
%p[%s][%r]
|
if the property /properties command was given and the qualifier /qualifiers command was not given
|
The format of a single claim. The available parameters are as follows.
Optional parameters can be given by encapsulating them between square brackets: To use two opening square brackets that directly follow each other (i.e. At least one parameter must be given that is not optional, while the To get a literal | ||||||||||||||||
%q[%s][%r]
|
if the property /properties command was not given and the qualifier /qualifiers command was given
| ||||||||||||||||||
%r
|
if only the reference /references command was given
| ||||||||||||||||||
%p[ <span style="font-size:85\%">(%q)</span>][%s][%r]
|
if the property /properties command was given and the qualifier /qualifiers command was given
| ||||||||||||||||||
%a[%s]
|
if the alias /aliases command was given
| ||||||||||||||||||
%b[%s]
|
if the badge /badges command was given
| ||||||||||||||||||
sep=
|
_
|
default | The fixed separator between each pair of claims. | ||||||||||||||||
|
if only the reference /references command was given without the raw flag
| ||||||||||||||||||
sep%s=
|
,
|
default | The movable separator between each pair of claims. This will be the value of the %s parameter applied to all claims except for the last in the list.
| ||||||||||||||||
;
|
if the property /properties command was not given and the qualifier /qualifiers command was given
| ||||||||||||||||||
sep%q1= , sep%q2= , sep%q3= , ...
|
,_
|
default | The separator between each pair of qualifiers of a single claim. These are the value separators for the %q1 , %q2 , %q3 , ... parameters.
If only one | ||||||||||||||||
sep%q=
|
,_
|
if exactly one qualifier /qualifiers command was given
|
The separator between each set of qualifiers of a single claim. This is the value separator for the %q parameter.
If only one | ||||||||||||||||
;_
|
if more than one qualifier /qualifiers command was given
| ||||||||||||||||||
sep%r=
|
|
default | The separator between each pair of references of a single claim. This is the value separator for the %r parameter.
| ||||||||||||||||
_
|
if the raw flag was given for the reference /references command
| ||||||||||||||||||
punc=
|
|
default | A punctuation mark placed at the end of the output. This will be placed on the %s parameter applied to the last claim in the list.
This allows any references to be placed after the punctuation mark when the output is used as part of a sentence. |
Examples
Parameters and output types | Example | Description |
---|---|---|
Q55 = "Neerlandiya", P395 = "licence plate code"
[string] |
{{#invoke:wd|property|Q55|P395}}
|
Gets a literal string value. |
P395 = "licence plate code"
[string] |
{{#invoke:wd|property|P395}}
|
If the module is transcluded on the Netherlands page (which is linked to Q55), then the Q55 can be omitted.
|
Q55 = "Neerlandiya", P395 = "NL"
[string] |
{{#invoke:wd|property|eid=Q55|P395}}
|
An entity-ID can also be given using the eid= argument.
|
Q55 = "Neerlandiya", P395 = "licence plate code"
[string] |
{{#invoke:wd|property|edit|Q55|P395}}
|
Adds a clickable icon that may be used to edit the returned value on Wikidata. |
Q55 = "Neerlandiya", P395 = "licence plate code"
[string] |
{{#invoke:wd|property|edit@end|Q55|P395}}
|
Places the edit icon at the end of the line. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[quantity] |
{{#invoke:wd|property|normal+|Q55|P1082}}
|
Gets a single property value from claims with a 'normal' rank or higher. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[quantity] |
{{#invoke:wd|properties|normal+|Q55|P1082}}
|
Gets multiple property values from claims with a 'normal' rank or higher. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[quantity], [time] |
{{#invoke:wd|properties|qualifier|normal+|Q55|P1082|P585}}
|
Gets a single qualifier value for each claim, additional to the property value. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[quantity], [time], [reference] |
{{#invoke:wd|properties|qualifier|references|normal+|Q55|P1082|P585}} |
Gets references for each claim. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[quantity], [reference] |
A total of
|
Gets a property with its references. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[quantity], [reference] |
The Netherlands has a population of
|
Adds a punctuation mark at the end of the output, in front of the references. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[quantity], [time], [reference] |
<ul>
|
Returns the output in a custom format. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[time] |
{{#invoke:wd|qualifier|normal+|Q55|P1082|P585}}
|
Gets a single qualifier per claim, by default for multiple matching claims. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[time] |
{{#invoke:wd|qualifier|normal+|single|Q55|P1082|P585}}
|
To get a single qualifier for only a single claim, give the single flag too so that only a single claim will be accessed.
|
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[time] |
{{#invoke:wd|qualifier|Q55|P1082|17590672|P585}}
|
Gets a qualifier from claims for which the (raw) property value matches a given literal value. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[time] |
{{#invoke:wd|qualifier|mdy|Q55|P1082|17590672|P585}}
|
Gets dates in month-day-year order. |
Q55 = "Neerlandiya", P1082 = "populasyon", P585 = "ayon sa panahon"
[time] |
{{#invoke:wd|qualifier|raw|Q55|P1082|17590672|P585}}
|
Gets a raw date value. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[reference] |
{{#invoke:wd|references|Q55|P1082|17590672}}
|
Gets the references from a particular claim. |
Q55 = "Neerlandiya", P1082 = "populasyon"
[reference] |
{{#invoke:wd|references|raw|Q55|P1082|17590672}} |
Gets references from a particular claim in their raw form. |
Q55 = "Neerlandiya", P1081 = "Human Development Index"
[quantity], [reference] |
{{#invoke:wd|properties|references|Q55|P1081}}
|
Gets properties from each claim with any references they have. |
Q55 = "Neerlandiya", P1081 = "Human Development Index"
[quantity], [reference] |
{{#invoke:wd|properties|references|sourced|Q55|P1081}}
|
Only gets properties from claims that have at least one reference. |
Q55 = "Neerlandiya", P2855 = "VAT rate", P518 = "applies to part"
[entity label] |
{{#invoke:wd|qualifier|Q55|P2855|P518}}
|
Gets a single qualifier value (for each matching claim). |
Q55 = "Neerlandiya", P2855 = "VAT rate", P518 = "applies to part"
[entity label] |
{{#invoke:wd|qualifiers|Q55|P2855|P518}}
|
Gets multiple qualifier values (for each matching claim). |
Q55 = "Neerlandiya", P2855 = "VAT rate", P518 = "applies to part"
[quantity], [entity label] |
{{#invoke:wd|properties|qualifiers|Q55|P2855|P518}}
|
Gets multiple property values along with multiple qualifier values. |
Q55 = "Neerlandiya", P2855 = "VAT rate", P518 = "applies to part"
[quantity], [entity label] |
{{#invoke:wd|properties|qualifiers|Q55|P2855|P518|sep=_+_|sep%s=}}
|
Returns the output with custom separators. |
Q55 = "Neerlandiya", P35 = "puno ng estado", P580 = "araw ng simula", P582 = "araw ng katapusan"
[entity label], [time] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580}}
|
Gets two different qualifier values for each claim. |
Q55 = "Neerlandiya", P35 = "puno ng estado", P580 = "araw ng simula", P582 = "araw ng katapusan"
[entity label], [time] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580}}
|
Returns the output with a custom separator. |
Q55 = "Neerlandiya", P35 = "puno ng estado", P580 = "araw ng simula", P582 = "araw ng katapusan"
[entity label], [time] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580}}
|
Returns the output in a custom format instead of with a custom separator. |
Q55 = "Neerlandiya", P35 = "puno ng estado", P580 = "araw ng simula", P582 = "araw ng katapusan"
[entity label], [time] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580}}
|
To add text only when a certain value is not present, like adding the word since if there is no end time, wrap it in between two optional blocks containing HTML comment tags and the relevant parameter (this also prevents the text from being added to the page source). |
Q55 = "Neerlandiya", P35 = "puno ng estado", Q29574 = "Beatrix of the Netherlands", P580 = "araw ng simula", P582 = "araw ng katapusan"
[entity label], [time] |
{{#invoke:wd|properties|qualifier|raw|qualifier|normal+|Q55|P35|Q29574}}
|
Gets a property with qualifiers from claims for which the property matches a given Q-identifier, with one of the qualifier values in its raw form. |
Q55 = "Neerlandiya", P38 = "pananalapi", P518 = "applies to part"
[entity label] |
{{#invoke:wd|properties|qualifiers|normal+|current|Q55|P38|P518}}
|
Gets claims that are currently valid. |
Q55 = "Neerlandiya", P38 = pananalapi", P518 = "applies to part"
[entity label] |
{{#invoke:wd|properties|linked|qualifiers|normal+|current|Q55|P38}}
|
Gets claims with linked property values. |
Q55 = "Neerlandiya", P38 = pananalapi", P518 = "applies to part"
[entity label] |
{{#invoke:wd|properties|qualifiers|linked|normal+|current|Q55|P38}}
|
Gets claims with linked qualifier values. |
Q55 = "Neerlandiya", P38 = pananalapi", P518 = "applies to part"
[entity label] |
{{#invoke:wd|properties|linked|short|qualifiers|linked|normal+|current}}
|
Gets claims with linked property and qualifier values, with short property values wherever available. |
Q55 = "Neerlandiya", P38 = pananalapi", Q4917 = "dolyar ng Estados Unidos", P518 = "applies to part"
[entity label] |
{{#invoke:wd|qualifiers|normal+|current|Q55|P38|Q4917|P518}}
|
Gets qualifiers from claims for which the (raw) property value matches a given Q-identifier. |
Q55 = "Neerlandiya", P38 = pananalapi", P518 = "applies to part", Q27561 = "Caribbean Netherlands"
[entity label] |
{{#invoke:wd|properties|normal+|current|Q55|P38|P518=Q27561}}
|
Gets properties from claims for which a (raw) qualifier value matches a given Q-identifier. |
Q55 = "Neerlandiya", P38 = pananalapi"
[entity label] |
{{#invoke:wd|properties|normal+|former|Q55|P38}}
|
Gets claims that were valid in the past. |
Q55 = "Neerlandiya", P38 = pananalapi"
[entity label] |
{{#invoke:wd|properties|raw|normal+|former|Q55|P38}}
|
Gets raw property values. |
Q55 = "Neerlandiya", P38 = pananalapi"
[entity label] |
{{#invoke:wd|properties|raw|linked|normal+|former|Q55|P38}}
|
Gets raw property values that are linked to Wikidata. |
Q55 = "Neerlandiya", P1549 = "demonym"
[monolingual text] |
{{#invoke:wd|property|Q55|P1549}}
|
Gets a monolingual text value in the current wiki's language. |
Q55 = "Neerlandiya", P1549 = "demonym", P407 = "wika ng trabaho o pangalan", Q36846 = "Toki Pona"
[monolingual text] |
{{#invoke:wd|property|multilanguage|Q55|P1549|P407=Q36846}}
|
Gets a monolingual text value in any available language. |
Q55 = "Neerlandiya", P2884 = "mains voltage"
[quantity] |
{{#invoke:wd|property|Q55|P2884}}
|
Gets a quantity value with its associated unit of measurement. |
Q55 = "Neerlandiya", P2884 = "mains voltage"
[quantity] |
{{#invoke:wd|property|linked|Q55|P2884}}
|
Gets a quantity value with a linked unit of measurement. |
Q55 = "Neerlandiya", P2884 = "mains voltage"
[quantity] |
{{#invoke:wd|property|raw|Q55|P2884}}
|
Gets a raw quantity value. |
Q55 = "Neerlandiya", P2884 = "mains voltage"
[quantity] |
{{#invoke:wd|property|unit|Q55|P2884}}
|
Gets only the unit of measurement. |
Q55 = "Neerlandiya", P2884 = "mains voltage"
[quantity] |
{{#invoke:wd|property|unit|raw|Q55|P2884}}
|
Gets the raw unit of measurement. |
Q55 = "Neerlandiya", P625 = "coordinate location"
[globe coordinate] |
{{#invoke:wd|property|Q55|P625}}
|
Gets a globe coordinate value. |
Q55 = "Neerlandiya", P625 = "coordinate location"
[globe coordinate] |
{{#invoke:wd|property|linked|Q55|P625}} |
Gets a linked globe coordinate value. |
Q55 = "Neerlandiya", P625 = "coordinate location"
[globe coordinate] |
{{#invoke:wd|property|raw|Q55|P625}}
|
Gets a raw globe coordinate value. |
Q55 = "Neerlandiya", P625 = "coordinate location"
[globe coordinate] |
{{#invoke:wd|property|Q55|coord}}
|
A property alias can be used instead of the P-identifier. |
Q55 = "Neerlandiya", P41 = "flag image"
[commons media] |
{{#invoke:wd|property|linked|Q55|P41}}
|
Gets a media file name and links to it on Commons. |
Q55 = "Neerlandiya", P41 = "flag image"
[commons media] |
{{#invoke:wd|property|raw|Q55|P41|format=\[\[File:%p {{!}} thumb {{!}} left\]\]}} |
A Commons media file can be included on the page as-is by omitting the linked and raw flags, but by using the raw flag it can be freely formatted.
|
Q915684 = "Lorentz–Lorenz equation", P2534 = "defining formula"
[math] |
{{#invoke:wd|property|Q915684|P2534}}
|
Gets a mathematical expression. |
Q6256 = "Bansa", P3896 = "geoshape"
[geographic shape] |
{{#invoke:wd|property|linked|Q6256|P3896}}
|
Gets a geographic shape data file name and links to it on Commons. |
Q4917 = "dolyar ng Estados Unidos"
[entity label] |
{{#invoke:wd|label|Q4917}}
|
Gets an item's label. |
Q4917 = "dolyar ng Estados Unidos"
[entity label] |
{{#invoke:wd|label|short|linked|Q4917}} |
Gets an item's short and linked label. |
P38 = pananalapi"
[entity label] |
{{#invoke:wd|label|P38}}
|
Gets a property's label. |
P38 = pananalapi"
[entity label] |
{{#invoke:wd|label|linked|P38}} |
Gets a property's label that is linked to Wikidata. |
Q776 = "Utrecht"
[entity label] |
{{#invoke:wd|label|Q776}}
|
Gets an item's label. |
Q776 = "Utrecht"
[entity label] |
{{#invoke:wd|label|linked|Q776}}
|
Gets an item's linked label. |
[entity label] |
{{#invoke:wd|label}}
|
If the module is transcluded on the page (which is linked to Q776), then the Q776 can be omitted.
|
[entity label] |
{{#invoke:wd|label|raw}}
|
If just the label command with the raw flag is given, then the Q-identifier of the item connected to the current page is returned.
|
Q776 = "Utrecht"
[page title] |
{{#invoke:wd|title|Q776}}
|
Gets the title of the page on the current wiki that is linked to the given item. |
Q776 = "Utrecht"
[page title] |
{{#invoke:wd|title|linked|Q776}}
|
Gets the linked title of the page on the current wiki that is linked to the given item. |
[page title] |
{{#invoke:wd|title}}
|
If the module is transcluded on the page (which is linked to Q776), then the Q776 can be omitted.
|
Q55 = "Neerlandiya"
[entity description] |
{{#invoke:wd|description|Q55}}
|
Gets an item's description. |
[entity description] |
{{#invoke:wd|description}}
|
If the module is transcluded on the Netherlands page (which is linked to Q55), then the Q55 can be omitted.
|
Q55 = "Neerlandiya"
[entity alias] |
{{#invoke:wd|alias|Q55}}
|
Gets one of an item's aliases. |
Q55 = "Neerlandiya"
[entity alias] |
{{#invoke:wd|aliases|Q55}}
|
Gets all of an item's aliases. |
Q55 = "Neerlandiya"
[entity alias] |
{{#invoke:wd|alias|linked|Q55}}
|
Gets a linked alias from an item. |
[entity alias] |
{{#invoke:wd|alias}}
|
If the module is transcluded on the Netherlands page (which is linked to Q55), then the Q55 can be omitted.
|
Q2 = "Daigdig"
[page badge] |
{{#invoke:wd|badges|Q2}}
|
Gets the badges for the page on the current wiki that is linked to the given item. |
Q2 = "Daigdig"
[page badge] |
{{#invoke:wd|badges|raw|Q2}}
|
Gets the raw badges for the page on the current wiki that is linked to the given item. |
[page badge] |
{{#invoke:wd|badges}}
|
If the module is transcluded on the Daigdig page (which is linked to Q2), then the Q2 can be omitted.
|
Example references
- ↑ 1.0 1.1 1.2 1.3 "Bevolking; kerncijfers (1950-2024)". Nakuha noong 22 Agosto 2024.
- ↑ 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 "Bevolking; kerncijfers, 1950-2022".
- ↑ 3.0 3.1 "Bevolking; kerncijfers, 1950-2022". Nakuha noong 18 Marso 2023.
- ↑ 4.0 4.1 "Nederland telt 17 miljoen inwoners". 21 Marso 2016.
- ↑ 5.0 5.1 "CBS StatLine - Bevolking; kerncijfers". Inarkibo mula sa orihinal noong 3 Setyembre 2014. Nakuha noong 26 Agosto 2014.
- ↑ 6.0 6.1 6.2 6.3 "CBS StatLine - Bevolking; kerncijfers". Statistics Netherlands. Inarkibo mula sa orihinal noong 27 Agosto 2015. Nakuha noong 22 Agosto 2015.
- ↑ "Human Development Data (1990-2017)". Inarkibo mula sa orihinal noong 30 Disyembre 2018.
See also
- {{Wikidata}}, a user-friendly wrapper template for this module.
- {{WikidataOI}}, a wrapper template for this module that adds an opt-in toggle.
- {{Pageid to title}}, to get a page title using its local page id, rather than Wikidata
local p = {}
local aliasesP = {
coord = "P625",
author = "P50",
publisher = "P123",
importedFrom = "P143",
statedIn = "P248",
publicationDate = "P577",
startTime = "P580",
endTime = "P582",
retrieved = "P813",
referenceURL = "P854",
archiveURL = "P1065",
title = "P1476",
quote = "P1683",
shortName = "P1813",
language = "P2439",
archiveDate = "P2960"
}
local aliasesQ = {
percentage = "Q11229",
prolepticJulianCalendar = "Q1985786"
}
local parameters = {
property = "%p",
qualifier = "%q",
reference = "%r",
separator = "%s",
general = "%x"
}
local formats = {
property = "%p[%s][%r]",
qualifier = "%q[%s][%r]",
reference = "%r",
propertyWithQualifier = "%p[ <span style=\"font-size:smaller\">(%q)</span>][%s][%r]"
}
local hookNames = { -- {level_1, level_2}
[parameters.property] = {"getProperty"},
[parameters.reference] = {"getReferences", "getReference"},
[parameters.qualifier] = {"getAllQualifiers"},
[parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"}
}
local defaultSeparators = {
["sep"] = " " ,
["sep%s"] = "," ,
["sep%q"] = "; " ,
["sep%q\\d"] = ", " ,
["sep%r"] = "" ,
["punc"] = ""
}
local Config = {}
Config.__index = Config
-- allows for recursive calls
function Config.new()
local cfg = {}
setmetatable(cfg, Config)
cfg.separators = {
-- use tables so that we can pass by reference
["sep"] = {defaultSeparators["sep"]},
["sep%s"] = {defaultSeparators["sep%s"]},
["sep%q"] = {defaultSeparators["sep%q"]},
["sep%r"] = {defaultSeparators["sep%r"]},
["punc"] = {defaultSeparators["punc"]}
}
cfg.entity = nil
cfg.propertyID = nil
cfg.propertyValue = nil
cfg.qualifierIDs = {}
cfg.bestRank = true
cfg.ranks = {true, true, false} -- preferred = true, normal = true, deprecated = false
cfg.foundRank = #cfg.ranks
cfg.flagBest = false
cfg.flagRank = false
cfg.periods = {true, true, true} -- future = true, current = true, former = true
cfg.flagPeriod = false
cfg.mdyDate = false
cfg.pageTitle = false
cfg.langCode = mw.language.getContentLanguage().code
cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode)
cfg.langObj = mw.language.new(cfg.langCode)
cfg.states = {}
cfg.states.qualifiersCount = 0
cfg.curState = nil
return cfg
end
local State = {}
State.__index = State
function State.new(cfg)
local stt = {}
setmetatable(stt, State)
stt.conf = cfg
stt.results = {}
stt.parsedFormat = {}
stt.separator = {}
stt.movSeparator = {}
stt.puncMark = {}
stt.linked = false
stt.rawValue = false
stt.shortName = false
stt.singleValue = false
return stt
end
function unknownDataTypeError(dataType)
return "Unknown or unsupported datatype '" .. dataType .. "'"
end
function missingRequiredParameterError()
return "No required parameters defined, needing at least one"
end
function extraRequiredParameterError(param)
return "Parameter '" .. param .. "' must be defined as optional"
end
-- used to make frame.args mutable and to replace #frame.args (which is always 0) with the actual amount
function copyTable(tIn)
local tOut = {}
for i, v in pairs(tIn) do
tOut[i] = v
end
return tOut
end
-- used to merge output tables together;
-- note that it currently mutates the first input table
function mergeTables(t1, t2)
for i = 1, #t2 do
t1[#t1 + 1] = t2[i]
end
return t1
end
-- used to create the final output string when it's all done,
-- so that extensionTag("ref") is only called when it's really in the final output
function concatValues(valuesArray)
local outString = ""
for i = 1, #valuesArray do
if valuesArray[i].refHash then
-- add <ref> tag with the reference's hash as its name (to deduplicate references)
outString = outString .. mw.getCurrentFrame():extensionTag("ref", valuesArray[i][1], {name = "wikidata-" .. valuesArray[i].refHash})
else
outString = outString .. valuesArray[i][1]
end
end
return outString
end
function getHookName(param, index)
if hookNames[param] then
return hookNames[param][index]
elseif string.len(param) > 2 then
return hookNames[string.sub(param, 1, 2).."\\d"][index]
else
return nil
end
end
function parseWikidataURL(url)
local i, j
if url:match('^http[s]?://') then
i, j = url:find("Q")
if i then
return url:sub(i)
end
end
return nil
end
function parseDate(dateStr, precision)
precision = precision or "d"
local i, j, index, ptr
local parts = {nil, nil, nil}
if dateStr == nil then
return parts[1], parts[2], parts[3] -- year, month, day
end
-- 'T' for snak values, '/' for outputs with '/Julian' attached
i, j = dateStr:find("[T/]")
if i then
dateStr = dateStr:sub(1, i-1)
end
local from = 1
if dateStr:sub(1,1) == "-" then
-- this is a negative number, look further ahead
from = 2
end
index = 1
ptr = 1
i, j = dateStr:find("-", from)
if i then
-- year
parts[index] = tonumber(mw.ustring.gsub(dateStr:sub(ptr, i-1), "^\+(.+)$", "%1"), 10) -- remove + sign
if parts[index] == -0 then
parts[index] = 0
end
if precision == "y" then
-- we're done
return parts[1], parts[2], parts[3] -- year, month, day
end
index = index + 1
ptr = i + 1
i, j = dateStr:find("-", ptr)
if i then
-- month
parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)
if precision == "m" then
-- we're done
return parts[1], parts[2], parts[3] -- year, month, day
end
index = index + 1
ptr = i + 1
end
end
if dateStr:sub(ptr) ~= "" then
-- day if we have month, month if we have year, or year
parts[index] = tonumber(dateStr:sub(ptr), 10)
end
return parts[1], parts[2], parts[3] -- year, month, day
end
function convertUnit(unit, link)
link = link or false
local itemID, label, title
if unit == "" or unit == "1" then
return nil
end
itemID = parseWikidataURL(unit)
if itemID then
if itemID == aliasesQ.percentage then
return "%"
else
label = mw.wikibase.label(itemID)
title = nil
if link or label == nil then
title = mw.wikibase.sitelink(itemID)
end
if link then
if title then
return " " .. "[[" .. title .. "|" .. (label or title) .. "]]"
end
if not label then
return " " .. "[[d:" .. itemID .. "|" .. itemID .. "]]"
end
end
return " " .. (label or title or itemID)
end
end
return " " .. unit
end
function getOrdinalSuffix(num)
if tostring(num):sub(-2,-2) == '1' then
return "th" -- 10th, 11th, 12th, 13th, ... 19th
end
num = tostring(num):sub(-1)
if num == '1' then
return "st"
elseif num == '2' then
return "nd"
elseif num == '3' then
return "rd"
else
return "th"
end
end
function addDecimalMarks(n)
local left,num,right = string.match(n,'^([^%d]*%d)(%d*)(.-)$')
return left..(num:reverse():gsub('(%d%d%d)','%1,'):reverse())..right
end
function convertRank(rank)
if rank == "preferred" then
return 1
elseif rank == "normal" then
return 2
elseif rank == "deprecated" then
return 3
else
return 4 -- default (in its literal sense)
end
end
function datePrecedesDate(aY, aM, aD, bY, bM, bD)
if aY == nil or bY == nil then
return nil
end
aM = aM or 1
aD = aD or 1
bM = bM or 1
bD = bD or 1
if aY < bY then
return true
end
if aY > bY then
return false
end
if aM < bM then
return true
end
if aM > bM then
return false
end
if aD < bD then
return true
end
return false
end
function alwaysTrue()
return true
end
-- The following function parses a format string.
--
-- The example below shows how a parsed string is structured in memory.
-- Variables other than 'str' and 'child' are left out for clarity's sake.
--
-- Example:
-- "A %p B [%s[%q1]] C [%r] D"
--
-- Structure:
-- [
-- {
-- str = "A "
-- },
-- {
-- str = "%p"
-- },
-- {
-- str = " B ",
-- child =
-- [
-- {
-- str = "%s",
-- child =
-- [
-- {
-- str = "%q1"
-- }
-- ]
-- }
-- ]
-- },
-- {
-- str = " C ",
-- child =
-- [
-- {
-- str = "%r"
-- }
-- ]
-- },
-- {
-- str = " D"
-- }
-- ]
--
function parseFormat(str)
local chr, esc, param, root, cur, prev, new
local params = {}
local function newObject(array)
local obj = {} -- new object
obj.str = ""
array[#array + 1] = obj -- array{object}
obj.parent = array
return obj
end
local function endParam()
if param > 0 then
if cur.str ~= "" then
cur.str = "%"..cur.str
cur.param = true
params[cur.str] = true
cur.parent.req[cur.str] = true
prev = cur
cur = newObject(cur.parent)
end
param = 0
end
end
root = {} -- array
root.req = {}
cur = newObject(root)
prev = nil
esc = false
param = 0
for i = 1, #str do
chr = str:sub(i,i)
if not esc then
if chr == '\\' then
endParam()
esc = true
elseif chr == '%' then
endParam()
if cur.str ~= "" then
cur = newObject(cur.parent)
end
param = 2
elseif chr == '[' then
endParam()
if prev and cur.str == "" then
table.remove(cur.parent)
cur = prev
end
cur.child = {} -- new array
cur.child.req = {}
cur.child.parent = cur
cur = newObject(cur.child)
elseif chr == ']' then
endParam()
if cur.parent.parent then
new = newObject(cur.parent.parent.parent)
if cur.str == "" then
table.remove(cur.parent)
end
cur = new
end
else
if param > 1 then
param = param - 1
elseif param == 1 then
if not string.match(chr, '%d') then
endParam()
end
end
cur.str = cur.str .. chr
end
else
cur.str = cur.str .. chr
esc = false
end
prev = nil
end
endParam()
return root, params
end
function sortOnRank(claims)
local rankPos
local ranks = {{}, {}, {}, {}} -- preferred, normal, deprecated, (default)
local sorted = {}
for i, v in ipairs(claims) do
rankPos = convertRank(v.rank)
ranks[rankPos][#ranks[rankPos] + 1] = v
end
sorted = ranks[1]
sorted = mergeTables(sorted, ranks[2])
sorted = mergeTables(sorted, ranks[3])
return sorted
end
function getShortName(itemID)
return p._property({itemID, aliasesP.shortName}) -- "property" is single
end
function getLabel(ID)
return p._label({ID})
end
function Config:getValue(snak, raw, link, short, anyLang)
raw = raw or false
link = link or false
short = short or false
anyLang = anyLang or false
if snak.snaktype == 'value' then
if snak.datavalue.type == 'string' then
return snak.datavalue.value
elseif snak.datavalue.type == 'monolingualtext' then
if anyLang then
return snak.datavalue.value['text'], snak.datavalue.value['language']
elseif snak.datavalue.value['language'] == self.langCode then
return snak.datavalue.value['text']
else
return nil
end
elseif snak.datavalue.type == 'quantity' then
-- strip + signs from front
local value = mw.ustring.gsub(snak.datavalue.value['amount'], "^\+(.+)$", "%1")
if not raw then
value = addDecimalMarks(value)
local unit = convertUnit(snak.datavalue.value['unit'], link)
if unit then
value = value .. unit
end
end
return value
elseif snak.datavalue.type == 'time' then
local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr
local yFactor = 1
local sign = 1
local suffix = ""
local mayAddCalendar = false
local calendar = ""
local precision = snak.datavalue.value['precision']
if precision == 11 then
p = "d"
elseif precision == 10 then
p = "m"
else
p = "y"
yFactor = 10^(9-precision)
end
y, m, d = parseDate(snak.datavalue.value['time'], p)
if y < 0 then
sign = -1
y = y * sign
end
-- if precision is tens/hundreds/thousands/millions/billions of years
if precision <= 8 then
yDiv = y / yFactor
-- if precision is tens/hundreds/thousands of years
if precision >= 6 then
mayAddCalendar = true
if precision <= 7 then
-- round centuries/millenniums up (e.g. 20th century or 3rd millennium)
yRound = math.ceil(yDiv)
if not raw then
if precision == 6 then
suffix = " millennium"
else
suffix = " century"
end
suffix = getOrdinalSuffix(yRound) .. suffix
else
-- if not verbose, take the first year of the century/millennium
-- (e.g. 1901 for 20th century or 2001 for 3rd millennium)
yRound = (yRound - 1) * yFactor + 1
end
else
-- precision == 8
-- round decades down (e.g. 2010s)
yRound = math.floor(yDiv) * yFactor
if not raw then
suffix = "s"
end
end
if raw and sign < 0 then
-- if BCE then compensate for "counting backwards"
-- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE)
yRound = yRound + yFactor - 1
end
else
local yReFactor, yReDiv, yReRound
-- round to nearest for tens of thousands of years or more
yRound = math.floor(yDiv + 0.5)
if yRound == 0 then
if precision <= 2 and y ~= 0 then
yReFactor = 1e6
yReDiv = y / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to millions of years only if we have a whole number of them
precision = 3
yFactor = yReFactor
yRound = yReRound
end
end
if yRound == 0 then
-- otherwise, take the unrounded (original) number of years
precision = 5
yFactor = 1
yRound = y
mayAddCalendar = true
end
end
if precision >= 1 and y ~= 0 then
yFull = yRound * yFactor
yReFactor = 1e9
yReDiv = yFull / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to billions of years if we're in that range
precision = 0
yFactor = yReFactor
yRound = yReRound
else
yReFactor = 1e6
yReDiv = yFull / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to millions of years if we're in that range
precision = 3
yFactor = yReFactor
yRound = yReRound
end
end
end
if not raw then
if precision == 3 then
suffix = " million years"
elseif precision == 0 then
suffix = " billion years"
else
yRound = yRound * yFactor
if yRound == 1 then
suffix = " year"
else
suffix = " years"
end
end
else
yRound = yRound * yFactor
end
end
else
yRound = y
mayAddCalendar = true
end
if mayAddCalendar then
calendarID = parseWikidataURL(snak.datavalue.value['calendarmodel'])
if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then
if not raw then
if link then
calendar = " ([[Julian calendar|Julian]])"
else
calendar = " (Julian)"
end
else
calendar = "/Julian"
end
end
end
if not raw then
local ce = nil
if sign < 0 then
ce = "BCE"
elseif precision <= 5 then
ce = "CE"
end
if ce then
if link then
ce = "[[Common Era|" .. ce .. "]]"
end
suffix = suffix .. " " .. ce
end
value = tostring(yRound)
if m then
dateStr = self.langObj:formatDate("F", "1-"..m.."-1")
if d then
if self.mdyDate then
dateStr = dateStr .. " " .. d .. ","
else
dateStr = d .. " " .. dateStr
end
end
value = dateStr .. " " .. value
end
value = value .. suffix .. calendar
else
value = tostring(yRound * sign)
if m then
value = value .. "-" .. m
if d then
value = value .. "-" .. d
end
end
value = value .. calendar
end
return value
elseif snak.datavalue.type == 'globecoordinate' then
-- logic from https://github.com/DataValues/Geo
local precision, numDigits, strFormat, value, globe
local latValue, latitude, latDegrees, latMinutes, latSeconds
local latDirection = "N"
local lonValue, longitude, lonDegrees, lonMinutes, lonSeconds
local lonDirection = "E"
local degSymbol = "°"
local minSymbol = "'"
local secSymbol = '"'
local partsGlue = ", "
if raw then
degSymbol = "/"
minSymbol = "/"
secSymbol = "/"
partsGlue = "/"
end
latitude = snak.datavalue.value['latitude']
longitude = snak.datavalue.value['longitude']
if latitude < 0 then
latDirection = "S"
latitude = math.abs(latitude)
end
if longitude < 0 then
lonDirection = "W"
longitude = math.abs(longitude)
end
precision = snak.datavalue.value['precision']
latitude = math.floor(latitude / precision + 0.5) * precision
longitude = math.floor(longitude / precision + 0.5) * precision
numDigits = math.ceil(-math.log10(3600 * precision))
if numDigits < 0 or numDigits == -0 then
numDigits = 0
end
strFormat = "%." .. numDigits .. "f"
-- use string.format() to strip decimal point followed by a zero (.0) for whole numbers
latSeconds = tonumber(string.format(strFormat, math.floor(latitude * 3600 * 10^numDigits + 0.5) / 10^numDigits))
lonSeconds = tonumber(string.format(strFormat, math.floor(longitude * 3600 * 10^numDigits + 0.5) / 10^numDigits))
latMinutes = math.floor(latSeconds / 60)
lonMinutes = math.floor(lonSeconds / 60)
latSeconds = latSeconds - (latMinutes * 60)
lonSeconds = lonSeconds - (lonMinutes * 60)
latDegrees = math.floor(latMinutes / 60)
lonDegrees = math.floor(lonMinutes / 60)
latMinutes = latMinutes - (latDegrees * 60)
lonMinutes = lonMinutes - (lonDegrees * 60)
latValue = latDegrees .. degSymbol
lonValue = lonDegrees .. degSymbol
if precision < 1 then
latValue = latValue .. latMinutes .. minSymbol
lonValue = lonValue .. lonMinutes .. minSymbol
end
if precision < (1 / 60) then
latSeconds = string.format(strFormat, latSeconds)
lonSeconds = string.format(strFormat, lonSeconds)
latValue = latValue .. latSeconds .. secSymbol
lonValue = lonValue .. lonSeconds .. secSymbol
end
latValue = latValue .. latDirection
lonValue = lonValue .. lonDirection
value = latValue .. partsGlue .. lonValue
if link then
globe = parseWikidataURL(snak.datavalue.value['globe'])
if globe then
globe = mw.wikibase.label(globe):lower()
else
globe = "earth"
end
value = "[https://tools.wmflabs.org/geohack/geohack.php?language="..self.langCode.."¶ms="..latitude.."_"..latDirection.."_"..longitude.."_"..lonDirection.."_globe:"..globe.." "..value.."]"
end
return value
elseif snak.datavalue.type == 'wikibase-entityid' then
local value = ""
local title = nil
local itemID = "Q" .. snak.datavalue.value['numeric-id']
if raw then
if link then
return "[[d:" .. itemID .. "|" .. itemID .. "]]"
else
return itemID
end
end
if short then
value = getShortName(itemID)
end
if value == "" then
value = mw.wikibase.label(itemID)
end
if link or value == nil then
title = mw.wikibase.sitelink(itemID)
end
if link then
if title then
value = "[[" .. title .. "|" .. (value or title) .. "]]"
elseif not value then
value = "[[d:" .. itemID .. "|" .. itemID .. "]]"
end
elseif not value then
value = (title or itemID)
end
return value
else
return '<strong class="error">' .. unknownDataTypeError(snak.datavalue.type) .. '.</strong>'
end
elseif snak.snaktype == 'somevalue' then
if raw then
return " " -- single space represents 'somevalue'
else
return "unknown"
end
elseif snak.snaktype == 'novalue' then
if raw then
return "" -- empty string represents 'novalue'
else
return "none"
end
else
return nil
end
end
function Config:getSingleRawQualifier(claim, qualifierID)
local qualifiers
if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end
if qualifiers and qualifiers[1] then
return self:getValue(qualifiers[1], true) -- raw = true
else
return nil
end
end
function Config:snakEqualsValue(snak, value)
local snakValue = self:getValue(snak, true) -- raw = true
if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end
return snakValue == value
end
function Config:setRank(rank)
local rankPos
if rank == "best" then
self.bestRank = true
self.flagBest = true -- mark that 'best' flag was given
return
end
if rank:sub(1,9) == "preferred" then
rankPos = 1
elseif rank:sub(1,6) == "normal" then
rankPos = 2
elseif rank:sub(1,10) == "deprecated" then
rankPos = 3
else
return
end
-- one of the rank flags was given, check if another one was given before
if not self.flagRank then
self.ranks = {false, false, false} -- no other rank flag given before, so unset ranks
self.bestRank = self.flagBest -- unsets bestRank only if 'best' flag was not given before
self.flagRank = true -- mark that a rank flag was given
end
if rank:sub(-1) == "+" then
for i = rankPos, 1, -1 do
self.ranks[i] = true
end
elseif rank:sub(-1) == "-" then
for i = rankPos, #self.ranks do
self.ranks[i] = true
end
else
self.ranks[rankPos] = true
end
end
function Config:setPeriod(period)
local periodPos
if period == "future" then
periodPos = 1
elseif period == "current" then
periodPos = 2
elseif period == "former" then
periodPos = 3
else
return
end
-- one of the period flags was given, check if another one was given before
if not self.flagPeriod then
self.periods = {false, false, false} -- no other period flag given before, so unset periods
self.flagPeriod = true -- mark that a period flag was given
end
self.periods[periodPos] = true
end
function Config:processFlag(flag)
if not flag then
return false
else
flag = mw.text.trim(flag)
end
if flag == "linked" then
self.curState.linked = true
return true
elseif flag == "raw" then
self.curState.rawValue = true
if self.curState == self.states[parameters.reference] then
-- raw reference values end with periods and require a separator different from ""
self.separators["sep%r"][1] = " "
end
return true
elseif flag == "short" then
self.curState.shortName = true
return true
elseif flag == "mdy" then
self.mdyDate = true
return true
elseif flag == "best" or flag:match('^preferred[+-]?$') or flag:match('^normal[+-]?$') or flag:match('^deprecated[+-]?$') then
self:setRank(flag)
return true
elseif flag == "future" or flag == "current" or flag == "former" then
self:setPeriod(flag)
return true
elseif flag == "" then
-- ignore empty flags and carry on
return true
else
return false
end
end
function Config:processFlagOrCommand(flag)
local param = ""
if not flag then
return false
else
flag = mw.text.trim(flag)
end
if flag == "property" or flag == "properties" then
param = parameters.property
elseif flag:match('^qualifier[s]?$') then
self.states.qualifiersCount = self.states.qualifiersCount + 1
param = parameters.qualifier .. self.states.qualifiersCount
self.separators["sep"..param] = {defaultSeparators["sep%q\\d"]}
elseif flag:match('^reference[s]?$') then
param = parameters.reference
else
return self:processFlag(flag)
end
if self.states[param] then
return false
end
-- create a new State for each command
self.states[param] = State.new(self)
-- use "%x" as the general parameter name
self.states[param].parsedFormat = parseFormat(parameters.general) -- will be overwritten for param=="%p"
-- set the separator
self.states[param].separator = self.separators["sep"..param] -- will be nil for param=="%p", which will be set separately
if string.sub(flag, -1) ~= 's' then
self.states[param].singleValue = true
end
self.curState = self.states[param]
return true
end
function Config:rankMatches(rankPos)
if self.bestRank then
return (self.ranks[rankPos] and self.foundRank >= rankPos)
else
return self.ranks[rankPos]
end
end
function Config:timeMatches(claim)
local startTime = nil
local startTimeY = nil
local startTimeM = nil
local startTimeD = nil
local endTime = nil
local endTimeY = nil
local endTimeM = nil
local endTimeD = nil
if self.periods[1] and self.periods[2] and self.periods[3] then
-- any time
return true
end
local now = os.date('!*t')
startTime = self:getSingleRawQualifier(claim, aliasesP.startTime)
if startTime and startTime ~= "" and startTime ~= " " then
startTimeY, startTimeM, startTimeD = parseDate(startTime)
end
endTime = self:getSingleRawQualifier(claim, aliasesP.endTime)
if endTime and endTime ~= "" and endTime ~= " " then
endTimeY, endTimeM, endTimeD = parseDate(endTime)
elseif endTime == " " then
-- end time is 'unknown', assume it is somewhere in the past;
-- we can do this by taking the current date as a placeholder for the end time
endTimeY = now['year']
endTimeM = now['month']
endTimeD = now['day']
end
if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then
-- invalidate end time if it precedes start time
endTimeY = nil
endTimeM = nil
endTimeD = nil
end
if self.periods[1] then
-- future
if startTimeY and datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD) then
return true
end
end
if self.periods[2] then
-- current
if (startTimeY == nil or not datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD)) and
(endTimeY == nil or datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD)) then
return true
end
end
if self.periods[3] then
-- former
if endTimeY and not datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD) then
return true
end
end
return false
end
function State:claimMatches(claim)
local matches, rankPos
-- if a property value was given, check if it matches the claim's property value
if self.conf.propertyValue then
matches = self.conf:snakEqualsValue(claim.mainsnak, self.conf.propertyValue)
else
matches = true
end
-- check if the claim's rank and time period match
rankPos = convertRank(claim.rank)
matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim))
return matches, rankPos
end
function State:out()
local result -- collection of arrays with value objects
local valuesArray -- array with value objects
local sep = ""
local out = {} -- array with value objects
local function walk(formatTable, result)
local valuesArray = {} -- array with value objects
for i, v in pairs(formatTable.req) do
if not result[i] or not result[i][1] then
-- we've got no result for a parameter that is required on this level,
-- so skip this level (and its children) by returning an empty result
return {}
end
end
for i, v in ipairs(formatTable) do
if v.param then
valuesArray = mergeTables(valuesArray, result[v.str])
else
valuesArray[#valuesArray + 1] = {v.str}
end
if v.child then
valuesArray = mergeTables(valuesArray, walk(v.child, result))
end
end
return valuesArray
end
-- iterate through the results from back to front, so that we know when to add separators
for i = #self.results, 1, -1 do
result = self.results[i]
-- if there is already some output, then add the separators
if #out > 0 then
sep = self.separator[1] -- fixed separator
result[parameters.separator] = { {self.movSeparator[1]} } -- movable separator
else
sep = ""
result[parameters.separator] = { {self.puncMark[1]} } -- optional punctuation mark
end
valuesArray = walk(self.parsedFormat, result)
if #valuesArray > 0 then
valuesArray[#valuesArray + 1] = {sep}
out = mergeTables(valuesArray, out)
end
end
-- reset state before next iteration
self.results = {}
return out
end
-- level 1 hook
function State:getProperty(claim)
local value = {self.conf:getValue(claim.mainsnak, self.rawValue, self.linked, self.shortName)} -- create one value object
if #value > 0 then
return {value} -- wrap the value object in an array and return it
else
return {} -- return empty array if there was no value
end
end
-- level 1 hook
function State:getQualifiers(claim, param)
local qualifiers
if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierIDs[param]] end
if qualifiers then
-- iterate through claim's qualifier statements to collect their values;
-- return array with multiple value objects
return self.conf.states[param]:iterate(qualifiers, {[parameters.general] = hookNames[parameters.qualifier.."\\d"][2], count = 1}) -- pass qualifier State with level 2 hook
else
return {} -- return empty array
end
end
-- level 2 hook
function State:getQualifier(snak)
local value = {self.conf:getValue(snak, self.rawValue, self.linked, self.shortName)} -- create one value object
if #value > 0 then
return {value} -- wrap the value object in an array and return it
else
return {} -- return empty array if there was no value
end
end
-- level 1 hook
function State:getAllQualifiers(claim, param, result, hooks)
local out = {} -- array with value objects
local sep = self.conf.separators["sep"..parameters.qualifier][1]
-- iterate through the output of the separate "qualifier(s)" commands
for i = 1, self.conf.states.qualifiersCount do
-- if a hook has not been called yet, call it now
if not result[parameters.qualifier..i] then
self:callHook(parameters.qualifier..i, hooks, claim, result)
end
-- if there is output for this particular "qualifier(s)" command, then add it
if result[parameters.qualifier..i] and result[parameters.qualifier..i][1] then
-- if there is already some output, then add the separator
if #out > 0 then
out[#out + 1] = {sep}
end
out = mergeTables(out, result[parameters.qualifier..i])
end
end
return out
end
-- level 1 hook
function State:getReferences(claim)
if claim.references then
-- iterate through claim's reference statements to collect their values;
-- return array with multiple value objects
return self.conf.states[parameters.reference]:iterate(claim.references, {[parameters.general] = hookNames[parameters.reference][2], count = 1}) -- pass reference State with level 2 hook
else
return {} -- return empty array
end
end
-- level 2 hook
-- logic determined based on https://www.wikidata.org/wiki/Help:Sources
function State:getReference(statement)
local snakValue, lang, property
local value = ""
local ref = {}
local snaks = {}
local params = {}
local leadParams = {}
if statement.snaks then
for i, v in pairs(statement.snaks) do
if v[1] then
snaks[i] = v[1]
end
end
if snaks[aliasesP.importedFrom] then
snaks[aliasesP.importedFrom] = nil
end
if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] then
params["url"] = self.conf:getValue(snaks[aliasesP.referenceURL])
params["title"] = self.conf:getValue(snaks[aliasesP.title], false, false, false, true) -- anyLang = true
if snaks[aliasesP.publicationDate] then params["date"] = self.conf:getValue(snaks[aliasesP.publicationDate]) end
if snaks[aliasesP.retrieved] then params["access-date"] = self.conf:getValue(snaks[aliasesP.retrieved]) end
if snaks[aliasesP.archiveURL] then params["archive-url"] = self.conf:getValue(snaks[aliasesP.archiveURL]) end
if snaks[aliasesP.archiveDate] then params["archive-date"] = self.conf:getValue(snaks[aliasesP.archiveDate]) end
if snaks[aliasesP.author] then params["author"] = self.conf:getValue(snaks[aliasesP.author]) end
if snaks[aliasesP.publisher] then params["publisher"] = self.conf:getValue(snaks[aliasesP.publisher]) end
if snaks[aliasesP.quote] then params["quote"] = self.conf:getValue(snaks[aliasesP.quote], false, false, false, true) end -- anyLang = true
if snaks[aliasesP.language] then
snakValue = self.conf:getValue(snaks[aliasesP.language])
if self.conf.langName ~= snakValue then
params["language"] = snakValue
end
end
value = mw.getCurrentFrame():expandTemplate{title="cite_web", args=params}
else
for i, v in pairs(snaks) do
property = getLabel(i)
if property ~= "" then
snakValue, lang = self.conf:getValue(v, false, (i == aliasesP.statedIn), false, true) -- link = true/false, anyLang = true
if lang and lang ~= self.conf.langCode then
snakValue = "''" .. snakValue .. "'' (" .. mw.language.fetchLanguageName(lang, self.conf.langCode) .. ")"
end
if i == aliasesP.referenceURL or i == aliasesP.statedIn then
leadParams[#leadParams + 1] = snakValue
elseif i ~= aliasesP.language or self.conf.langName ~= snakValue then
params[#params + 1] = property .. ": " .. snakValue
end
end
end
value = table.concat(leadParams, "; ")
params = table.concat(params, "; ")
if params ~= "" then
if value ~= "" then
value = value .. "; "
end
value = value .. params
end
if value ~= "" then
value = value .. "."
end
end
if value ~= "" then
ref = {value} -- create one value object
if not self.rawValue then
-- this should become a <ref> tag, so safe the reference's hash for later
ref.refHash = statement.hash
end
ref = {ref} -- wrap the value object in an array
end
end
return ref
end
function State:callHook(param, hooks, statement, result)
local valuesArray, refHash
-- call a parameter's hook if it has been defined and if it has not been called before
if not result[param] and hooks[param] then
valuesArray = self[hooks[param]](self, statement, param, result, hooks) -- array with value objects
-- add to the result
if #valuesArray > 0 then
result[param] = valuesArray
result.count = result.count + 1
else
result[param] = {} -- an empty array to indicate that we've tried this hook already
return true -- miss == true
end
end
return false
end
-- iterate through claims, claim's qualifiers or claim's references to collect values
function State:iterate(statements, hooks, matchHook)
matchHook = matchHook or alwaysTrue
local matches = false
local rankPos = nil
local result, gotRequired
for i, v in ipairs(statements) do
-- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.)
matches, rankPos = matchHook(self, v)
if matches then
result = {count = 0} -- collection of arrays with value objects
local function walk(formatTable)
local miss
for i2, v2 in pairs(formatTable.req) do
-- call a hook, adding its return value to the result
miss = self:callHook(i2, hooks, v, result)
if miss then
-- we miss a required value for this level, so return false
return false
end
if result.count == hooks.count then
-- we're done if all hooks have been called;
-- returning at this point breaks the loop
return true
end
end
for i2, v2 in ipairs(formatTable) do
if result.count == hooks.count then
-- we're done if all hooks have been called;
-- returning at this point prevents further childs from being processed
return true
end
if v2.child then
walk(v2.child)
end
end
return true
end
gotRequired = walk(self.parsedFormat)
-- only append the result if we got values for all required parameters on the root level
if gotRequired then
-- if we have a rankPos (only with matchHook() for complete claims), then update the foundRank
if rankPos and self.conf.foundRank > rankPos then
self.conf.foundRank = rankPos
end
-- append the result
self.results[#self.results + 1] = result
-- break if we only need a single value
if self.singleValue then
break
end
end
end
end
return self:out()
end
function p.property(frame)
return p._property(copyTable(frame.args))
end
function p._property(args)
return execCommand(args, "property")
end
function p.properties(frame)
return p._properties(copyTable(frame.args))
end
function p._properties(args)
return execCommand(args, "properties")
end
function p.qualifier(frame)
return p._qualifier(copyTable(frame.args))
end
function p._qualifier(args)
return execCommand(args, "qualifier")
end
function p.qualifiers(frame)
return p._qualifiers(copyTable(frame.args))
end
function p._qualifiers(args)
return execCommand(args, "qualifiers")
end
function p.reference(frame)
return p._reference(copyTable(frame.args))
end
function p._reference(args)
return execCommand(args, "reference")
end
function p.references(frame)
return p._references(copyTable(frame.args))
end
function p._references(args)
return execCommand(args, "references")
end
function execCommand(args, funcName)
_ = Config.new()
_:processFlagOrCommand(funcName) -- process first command (== function name)
local parsedFormat, formatParams, claims
local hooks = {count = 0}
local nextArg = args[1]
local nextIndex = 2
-- process flags and commands
while _:processFlagOrCommand(nextArg) do
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
end
if nextArg then
nextArg = mw.text.trim(nextArg)
else
nextArg = ""
end
-- check for optional item ID
if nextArg:sub(1,1):upper() == "Q" then
_.entity = mw.wikibase.getEntity(nextArg) -- item ID given
_.propertyID = mw.text.trim(args[nextIndex] or "") -- property ID
nextIndex = nextIndex + 1
else
_.entity = mw.wikibase.getEntity() -- no item ID given, use item connected to current page
_.propertyID = nextArg -- property ID
end
-- check if given property ID is an alias
if aliasesP[_.propertyID] then
_.propertyID = aliasesP[_.propertyID]
end
_.propertyID = _.propertyID:upper()
if _.states.qualifiersCount > 0 then
-- do further processing if "qualifier(s)" command was given
if #args - nextIndex + 1 > _.states.qualifiersCount then
-- claim ID or literal value has been given
nextArg = args[nextIndex] -- don't trim because might be single space representing 'somevalue'
nextIndex = nextIndex + 1
_.propertyValue = nextArg
end
for i = 1, _.states.qualifiersCount do
nextArg = mw.text.trim(args[nextIndex] or "") -- is a qualifierID
nextIndex = nextIndex + 1
-- check if given qualifier ID is an alias
if aliasesP[nextArg] then
nextArg = aliasesP[nextArg]
end
_.qualifierIDs[parameters.qualifier..i] = nextArg:upper()
end
elseif _.states[parameters.reference] then
-- do further processing if "reference(s)" command was given
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
_.propertyValue = nextArg -- claim ID or literal value (possibly nil)
end
-- check for special property value 'somevalue' or 'novalue'
if _.propertyValue then
if _.propertyValue ~= "" and mw.text.trim(_.propertyValue) == "" then
_.propertyValue = " " -- single space represents 'somevalue', whereas empty string represents 'novalue'
else
_.propertyValue = mw.text.trim(_.propertyValue)
end
end
-- parse the desired format, or choose an appropriate format
if args["format"] then
parsedFormat, formatParams = parseFormat(mw.text.trim(args["format"]))
elseif _.states.qualifiersCount > 0 then
if _.states[parameters.property] then
parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier)
else
parsedFormat, formatParams = parseFormat(formats.qualifier)
end
elseif _.states[parameters.property] then
parsedFormat, formatParams = parseFormat(formats.property)
else
parsedFormat, formatParams = parseFormat(formats.reference)
-- if only "reference(s)" has been given, make the emtpy string the default separator (except when raw)
if not _.states[parameters.reference].rawValue then
_.separators["sep"][1] = ""
end
end
-- if exactly one "qualifier(s)" command has been given, make "sep%q" point to "sep%q1" to make them equivalent
-- must come BEFORE overriding the separator values
if _.states.qualifiersCount == 1 then
_.separators["sep"..parameters.qualifier] = _.separators["sep"..parameters.qualifier.."1"]
end
-- process overridden separator values;
-- must come AFTER parsing the formats
for i, v in pairs(_.separators) do
if args[i] then
_.separators[i][1] = args[i]
end
end
-- make sure that at least one required parameter has been defined
if not next(parsedFormat.req) then
error(missingRequiredParameterError())
end
-- make sure that the separator parameter "%s" is not amongst the required parameters
if parsedFormat.req[parameters.separator] then
error(extraRequiredParameterError(parameters.separator))
end
-- define the hooks that should be called (getProperty, getQualifiers, getReferences);
-- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given
for i, v in pairs(_.states) do
-- e.g. 'formatParams["%q1"] or formatParams["%q"]' to define hook even if "%q1" was not defined to be able to build a complete value for "%q"
if formatParams[i] or formatParams[string.sub(i, 1, 2)] then
hooks[i] = getHookName(i, 1)
hooks.count = hooks.count + 1
end
end
-- the "%q" parameter is not attached to a state, but is a collection of the results of multiple states (attached to "%q1", "%q2", "%q3", ...);
-- so if this parameter is given then this hook must be defined separately, but only if at least one "qualifier(s)" command has been given
if formatParams[parameters.qualifier] and _.states.qualifiersCount > 0 then
hooks[parameters.qualifier] = getHookName(parameters.qualifier, 1)
hooks.count = hooks.count + 1
end
-- create a state for "properties" if it doesn't exist yet, which will be used as a base configuration for each claim iteration;
-- must come AFTER defining the hooks
if not _.states[parameters.property] then
_.states[parameters.property] = State.new(_)
end
-- set the parsed format and the separators (and optional punctuation mark)
_.states[parameters.property].parsedFormat = parsedFormat
_.states[parameters.property].separator = _.separators["sep"]
_.states[parameters.property].movSeparator = _.separators["sep"..parameters.separator]
_.states[parameters.property].puncMark = _.separators["punc"]
if _.entity and _.entity.claims then claims = _.entity.claims[_.propertyID] end
if claims then
-- first sort the claims on rank to pre-define the order of output (preferred first, then normal, then deprecated)
claims = sortOnRank(claims)
-- then iterate through the claims to collect values
return concatValues(_.states[parameters.property]:iterate(claims, hooks, State.claimMatches)) -- pass property State with level 1 hooks and matchHook
else
return ""
end
end
function p.label(frame)
return p._label(copyTable(frame.args))
end
function p._label(args, _)
_ = _ or Config.new()
_.curState = State.new(_)
local ID
local label = ""
local title = nil
local nextArg = args[1]
local nextIndex = 2
while _:processFlag(nextArg) do
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
end
if nextArg then
nextArg = mw.text.trim(nextArg)
else
nextArg = ""
end
ID = nextArg
if ID ~= "" then
if aliasesP[ID] then
ID = aliasesP[ID]
end
ID = ID:upper()
-- check if this is a valid ID, and if the number is not larger than max int (to prevent error)
if not string.match(ID, '^[QP]%d+$') or tonumber(string.match(ID, '%d+')) > 2147483647 then
return ""
end
if _.curState.rawValue then
if mw.wikibase.getEntity(ID) or mw.wikibase.resolvePropertyId(ID) then
if _.curState.linked then
if ID:sub(1,1) == "P" then
label = "[[d:Property:" .. ID .. "|" .. ID .. "]]"
else
label = "[[d:" .. ID .. "|" .. ID .. "]]"
end
else
label = ID
end
end
else
if ID:sub(1,1) == "P" then
if not _.pageTitle then
label = mw.wikibase.label(ID) or ""
if _.curState.linked and label ~= "" then
label = "[[d:Property:" .. ID .. "|" .. label .. "]]"
end
end
else
if not _.pageTitle then
if _.curState.shortName then
label = getShortName(ID)
end
-- at this point, 'label' will be a string and not nil
if label == "" then
label = mw.wikibase.label(ID)
end
else
-- set 'label' to nil so 'title' will always prevail
label = nil
end
-- at this point, 'label' will be nil or a non-empty string
if _.curState.linked or label == nil then
title = mw.wikibase.sitelink(ID)
end
if _.curState.linked and title then
label = "[[" .. title .. "|" .. (label or title) .. "]]"
else
label = label or title or ""
end
end
end
else
if _.curState.rawValue then
label = mw.wikibase.getEntityIdForCurrentPage() or ""
if _.curState.linked and label ~= "" then
label = "[[d:" .. label .. "|" .. label .. "]]"
end
else
if not _.pageTitle then
label = mw.wikibase.label()
else
-- set 'label' to nil so 'title' will always prevail
label = nil
end
if _.curState.linked or label == nil then
title = mw.title.getCurrentTitle().prefixedText
end
if _.curState.linked then
label = "[[" .. title .. "|" .. (label or title) .. "]]" -- not much use since it links to the current page, but does add wiki mark-up
else
label = label or title
end
end
end
return label
end
function p.title(frame)
return p._title(copyTable(frame.args))
end
function p._title(args, _)
_ = _ or Config.new()
_.pageTitle = true
return p._label(args, _)
end
-- main function that is supposed to be used by wrapper templates
function p.main(frame)
local f, args, i, v
-- get the parent frame to take the arguments that were passed to the wrapper template
frame = frame:getParent() or frame
f = mw.text.trim(frame.args[1] or "")
if f == "main" then
error('The function "main" cannot be called twice')
end
assert(p["_"..f], 'The function "' .. f .. '" does not exist')
-- copy arguments from immutable to mutable table
args = copyTable(frame.args)
-- remove the function name from the list
table.remove(args, 1)
return p["_"..f](args)
end
return p