« Module:Wikidata » : différence entre les versions
espace insécable après les indicatifs de langue |
rapatriement de Module:Wikidata/Récup, Module:Wikidata/Formatage entité et Module:Wikidata/Outils, voir Discussion module:Wikidata#Organisation |
||
Ligne 11 : | Ligne 11 : | ||
langmodule = 'Module:Langue', |
langmodule = 'Module:Langue', |
||
cite = 'Module:Biblio', |
cite = 'Module:Biblio', |
||
getData = 'Module:Wikidata/Récup', |
|||
entities = 'Module:Wikidata/Formatage entité', |
|||
tools = 'Module:Wikidata/Outils', |
|||
globes = 'Module:Wikidata/Globes', |
globes = 'Module:Wikidata/Globes', |
||
langcodes = 'Module:Dictionnaire Wikidata/Codes langue', -- gros et rarement utilisé |
langcodes = 'Module:Dictionnaire Wikidata/Codes langue', -- gros et rarement utilisé |
||
Ligne 28 : | Ligne 25 : | ||
setmetatable( modules, { __index = loadModule } ) |
setmetatable( modules, { __index = loadModule } ) |
||
-- i18n |
|||
local tools = require 'Module:Wikidata/Outils' |
|||
local translate = tools.translate |
|||
local defaultlang = mw.getContentLanguage():getCode() |
local defaultlang = mw.getContentLanguage():getCode() |
||
wd.i18n = require "Module:Wikidata/I18n" |
|||
local function translate(str, rep1, rep2) |
|||
str = wd.i18n[str] or str |
|||
if rep1 then |
|||
str = str:gsub('$1', rep1) |
|||
end |
|||
if rep2 then |
|||
str = str:gsub('$2', rep2) |
|||
end |
|||
return str |
|||
end |
|||
local datequalifiers = {'P585', 'P571', 'P580', 'P582'} |
|||
function wd.getLabel(entity, args) |
|||
modules.entities.getLabel(entity) |
|||
function wd.isSpecial(snak) |
|||
return (snak.snaktype ~= 'value') |
|||
end |
end |
||
function wd. |
function wd.getId(snak) |
||
if (snak.snaktype == 'value') then |
|||
return modules.entities.formatEntity(entity, args) |
|||
return 'Q' .. snak.datavalue.value['numeric-id'] |
|||
end |
|||
end |
end |
||
function wd.getNumericId(snak) |
|||
if (snak.snaktype == 'value') then |
|||
return snak.datavalue.value['numeric-id'] |
|||
end |
|||
end |
|||
function wd.getMainId(claim) |
|||
return wd.getId(claim.mainsnak) |
|||
end |
|||
function wd.EntityId(entity) |
|||
if type(entity) == 'string' then |
|||
return entity |
|||
end |
|||
return entity.id |
|||
end |
|||
function wd.getValue(snak) |
|||
return snak.datavalue.value |
|||
end |
|||
-- function that returns true if the "qid" parameter is the qid |
|||
-- of the item that is linked to the calling page |
|||
function wd.is_page_of_qid(qid) |
|||
local entity_on_its_page = false |
|||
local self_entity = mw.wikibase.getEntity() |
|||
if self_entity ~= nil and qid == wd.EntityId(self_entity) then |
|||
entity_on_its_page = true |
|||
end |
|||
return entity_on_its_page |
|||
end |
|||
function wd.formatError( key , category, debug) |
|||
if debug then |
|||
return error(wd.i18n[key] or key) |
|||
end |
|||
if category then |
|||
return "[[Category:" .. category .. "|" .. (key or "") .. "]]" |
|||
else |
|||
return "[[Catégorie:Page avec un problème de codage Wikidata|" .. (key or "") .. "]]" |
|||
end |
|||
end |
|||
function wd.addcat(cat, sortkey) |
|||
if sortkey then |
|||
return '[[Category:' .. cat .. '|' .. (sortkey or '') .. ']]' |
|||
end |
|||
return '[[Category:' .. cat .. ']]' |
|||
end |
|||
function wd.getEntity( val ) |
|||
if type(val) == 'table' then |
|||
return val |
|||
end |
|||
if val == '-' then |
|||
return nil |
|||
end |
|||
if val == '' then |
|||
val = nil |
|||
end |
|||
return mw.wikibase.getEntityObject(val) |
|||
end |
|||
function wd.splitStr(val) -- transforme en table les chaînes venant du Wikitexte qui utilisent des virgules de séparatin |
|||
if type(val) == 'string' then |
|||
val = mw.text.split(val, ",") |
|||
end |
|||
return val |
|||
end |
|||
function wd.isHere(searchset, val) |
|||
for i, j in pairs(searchset) do |
|||
if val == j then |
|||
return true |
|||
end |
|||
end |
|||
return false |
|||
end |
|||
function wd.getEntityPagename(entity) |
|||
if (not entity) then |
|||
return nil -- ou option de gestion des erreurs ? |
|||
end |
|||
local name ="d:" |
|||
if entity["type"] == "property" then |
|||
name = "d:Property:" |
|||
end |
|||
return name .. entity.id |
|||
end |
|||
function wd.getEntityPagename(entity) |
|||
if (not entity) then |
|||
return nil -- ou option de gestion des erreurs ? |
|||
end |
|||
local name ="d:" |
|||
if entity["type"] == "property" then |
|||
name = "d:Property:" |
|||
end |
|||
return name .. entity.id |
|||
end |
|||
local function wikidataLink(entity) |
|||
local name =':d:' |
|||
if type(entity) == 'string' then |
|||
if entity:match("P[0-9+]") then |
|||
entity = "Property:" .. entity |
|||
end |
|||
return name .. entity |
|||
elseif type(entity) == 'table' then |
|||
if entity["type"] == "property" then |
|||
name = ":d:Property:" |
|||
end |
|||
return name .. entity.id |
|||
elseif type(entity) == nil then |
|||
return formatError('entity-not-found') |
|||
end |
|||
end |
|||
function wd.siteLink(entity, project, lang) |
|||
-- returns 3 values: a sitelink (with the relevant prefix) a project name and a language |
|||
lang = lang or defaultlang |
|||
if (type(project) ~= 'string') then |
|||
project = 'wiki' |
|||
end |
|||
project = project:lower() |
|||
if project == 'wikipedia' then |
|||
project = 'wiki' |
|||
end |
|||
if type(entity) == 'string' and (project == 'wiki') and ( (not lang or lang == defaultlang) ) then -- évite de charger l'élément entier |
|||
return mw.wikibase.sitelink(entity), 'wiki', defaultlang |
|||
end |
|||
if project == 'wikidata' then |
|||
return wikidataLink(entity), 'wikidata' |
|||
end |
|||
local projects = { |
|||
-- nom = {préfixe sur Wikidata, préfix pour les liens sur Wikipédia, ajouter préfixe de langue} |
|||
wiki = {'wiki', nil, true}, -- wikipedia |
|||
commons = {'commonswiki', 'commons', false}, |
|||
commonswiki = {'commonswiki', 'commons', false}, |
|||
wikiquote = {'wikiquote', 'q', true}, |
|||
wikivoyage = {'wikivoyage', 'voy', true}, |
|||
wikibooks = {'wikibooks', 'b', true}, |
|||
wikinews = {'wikinews', 'n', true}, |
|||
wikiversity = {'wikiversity', 'v', true}, |
|||
wikisource = {'wikisource', 's', true}, |
|||
-- meta |
|||
-- mediawiki |
|||
} |
|||
entity = wd.getEntity(entity) |
|||
if not entity then |
|||
return nil |
|||
end |
|||
local projectdata = projects[project:lower()] |
|||
if not projectdata then -- sinon, on peut avoir des liens du type "enwiki" plutôt que "en" et lang = "wikipedia' |
|||
for k, v in pairs(projects) do |
|||
if project:match( k .. '$' ) |
|||
and mw.language.isKnownLanguageTag(project:sub(1, #project-#k)) |
|||
then |
|||
lang = project:sub(1, #project-#k) |
|||
projectdata = k |
|||
break |
|||
end |
|||
end |
|||
if not mw.language.isKnownLanguageTag(lang) then |
|||
return wd.formatError('invalid project code: ' .. (project or '?')) |
|||
end |
|||
end |
|||
if not projectdata then |
|||
return wd.formatError('invalid project code: ' .. (project or '?')) |
|||
end |
|||
local linkcode = projectdata[1] |
|||
local prefix = projectdata[2] |
|||
local multiversion = projectdata[3] |
|||
if multiversion then |
|||
linkcode = lang .. linkcode |
|||
end |
|||
local link = entity:getSitelink(linkcode) |
|||
if not link then |
|||
return nil |
|||
end |
|||
if prefix then |
|||
link = prefix .. ':' .. link |
|||
end |
|||
if multiversion then |
|||
link = ':' .. lang .. ':' .. link |
|||
end |
|||
return link, project, lang |
|||
end |
|||
-- add new values to a list, avoiding duplicates |
|||
function wd.addnewvalues(old, new) |
|||
if not new then |
|||
return old |
|||
end |
|||
for _, j in pairs(new) do |
|||
if not wd.isHere(old, j) then |
|||
table.insert(old, j) |
|||
end |
|||
end |
|||
return old |
|||
end |
|||
-- == FILTER CLAIMS ACCORDING TO VARIOUS CRITERIA : FUNCTION GETCLAIMS and affiliates |
|||
local function notSpecial(claim) |
|||
return (claim.mainsnak.snaktype == 'value') |
|||
end |
|||
local function hastargetvalue(claim, targets) -- retourne true si la valeur est dans la liste des target, ou si c'est une valeur spéciale filtrée séparément par excludespecial |
|||
local id = wd.getMainId(claim) |
|||
local targets = wd.splitStr(targets) |
|||
return wd.isHere(targets, id) or wd.isSpecial(claim.mainsnak) |
|||
end |
|||
local function excludevalues(claim, values) -- true si la valeur n'est pas dans la liste, ou si c'est une valeur spéciale (filtrée à part par excludespecial) |
|||
return wd.isSpecial(claim.mainsnak) or not ( hastargetvalue(claim, values) ) |
|||
end |
|||
local function bestranked(claims) |
|||
if not claims then |
|||
return nil |
|||
end |
|||
local preferred, normal = {}, {} |
|||
for i, j in pairs(claims) do |
|||
if j.rank == 'preferred' then |
|||
table.insert(preferred, j) |
|||
elseif j.rank == 'normal' then |
|||
table.insert(normal, j) |
|||
end |
|||
end |
|||
if #preferred > 0 then |
|||
return preferred |
|||
else |
|||
return normal |
|||
end |
|||
end |
|||
local function withrank(claims, target) |
|||
if target == 'best' then |
|||
return bestranked(claims) |
|||
end |
|||
local newclaims = {} |
|||
for pos, claim in pairs(claims) do |
|||
if target == 'valid' then |
|||
if claim.rank ~= 'deprecated' then |
|||
table.insert(newclaims, claim) |
|||
end |
|||
elseif claim.rank == target then |
|||
table.insert(newclaims, claim) |
|||
end |
|||
end |
|||
return newclaims |
|||
end |
|||
function wd.hasqualifier(claim, acceptedqualifs, acceptedvals, excludequalifiervalues) |
|||
local claimqualifs = claim.qualifiers |
|||
if (not claimqualifs) then |
|||
return false |
|||
end |
|||
acceptedqualifs = wd.splitStr(acceptedqualifs) |
|||
acceptedvals = wd.splitStr( acceptedvals) |
|||
local function ok(qualif) -- vérification pour un qualificatif individuel |
|||
if not claimqualifs[qualif] then |
|||
return false |
|||
end |
|||
if not (acceptedvals) then -- si aucune valeur spécifique n'est demandée, OK |
|||
return true |
|||
end |
|||
for i, wanted in pairs(acceptedvals) do |
|||
for j, actual in pairs(claimqualifs[qualif]) do |
|||
if wd.getId(actual) == wanted then |
|||
return true |
|||
end |
|||
end |
|||
end |
|||
end |
|||
for i, qualif in pairs(acceptedqualifs) do |
|||
if ok(qualif) then |
|||
return true |
|||
end |
|||
end |
|||
return false |
|||
end |
|||
local function hassource(claim, targetsource, sourceproperty) |
|||
sourceproperty = sourceproperty or 'P248' |
|||
if targetsource == "-" then |
|||
return true |
|||
end |
|||
if (not claim.references) then return |
|||
false |
|||
end |
|||
local candidates = claim.references[1].snaks[sourceproperty] -- les snaks utilisant la propriété demandée |
|||
if (not candidates) then |
|||
return false |
|||
end |
|||
if (targetsource == "any") then -- si n'importe quelle valeur est acceptée tant qu'elle utilise en ref la propriété demandée |
|||
return true |
|||
end |
|||
targetsource = wd.splitStr(targetsource) |
|||
for _, source in pairs(candidates) do |
|||
local s = wd.getId(source) |
|||
for i, target in pairs(targetsource) do |
|||
if s == target then return true end |
|||
end |
|||
end |
|||
return false |
|||
end |
|||
local function excludequalifier(claim, qualifier, qualifiervalues) |
|||
return not wd.hasqualifier(claim, qualifier, qualifiervalues) |
|||
end |
|||
local function hasdate(claim) |
|||
local claimqualifs = claims.qualifiers |
|||
if not claimqualifs then |
|||
return false |
|||
end |
|||
for _, qualif in pairs(claimqualifs) do |
|||
if claimsqualifs[qualif] and claimsqualifs[qualif][1].snaktype == 'value' then |
|||
return true |
|||
end |
|||
end |
|||
return false |
|||
end |
|||
local function haslink(claim, site, lang) |
|||
if (claim.mainsnak.snaktype ~= 'value') then -- ne pas supprimer les valeurs spéciales, il y a une fonction dédiée pour ça |
|||
return true |
|||
end |
|||
local id = wd.getMainId(claim) |
|||
local link = wd.siteLink(id, site, lang) |
|||
if link then |
|||
return true |
|||
end |
|||
end |
|||
local function isinlanguage(claim, lang) -- ne fonctionne que pour les monolingualtext / étendre aux autres types en utilisant les qualifiers ? |
|||
if type(lang) == 'table' then -- si c'est une table de language séparées par des virgules, on les accepte toutes |
|||
for i, l in pairs(lang) do |
|||
local v = isinlanguage(claim, l) |
|||
if v then |
|||
return true |
|||
end |
|||
end |
|||
end |
|||
if type(lang) ~= ('string') then |
|||
return --? |
|||
end |
|||
if (lang == '-') then |
|||
return true |
|||
end |
|||
if (lang == 'locallang') then |
|||
lang = mw.getContentLanguage():getCode() |
|||
end |
|||
-- pour les monolingual text |
|||
local mainsnak = claim.mainsnak |
|||
if ( notSpecial(claim)) and mainsnak.datavalue.type == 'monolingualtext' then |
|||
if (mainsnak.datavalue.value.language == lang) then |
|||
return true |
|||
end |
|||
return false |
|||
end |
|||
-- pour les autres types de données : recherche dans les qualificatifs |
|||
if (lang == 'fr') then |
|||
lang = 'Q150' |
|||
elseif (lang == 'en') then |
|||
lang = 'Q1860' |
|||
else |
|||
lang = require "Module:Dictionnaire Wikidata/Codes langue/inversé"[lang] |
|||
end |
|||
if claim.qualifiers and claim.qualifiers.P407 then |
|||
if wd.hasqualifier(claim, {'P407'}, {lang}) then |
|||
return true |
|||
else |
|||
return false |
|||
end |
|||
end |
|||
return true -- si on ne ne sait pas la langue, on condière que c'est bon |
|||
end |
|||
local function firstvals(claims, numval) -- retourn les numval premières valeurs de la table claims |
|||
local numval = tonumber(numval) or 0 -- raise a error if numval is not a positive integer ? |
|||
if not claims then |
|||
return nil |
|||
end |
|||
while (#claims > numval) do |
|||
table.remove(claims) |
|||
end |
|||
return claims |
|||
end |
|||
local function valinQualif(claim, qualifs) |
|||
local claimqualifs = claim.qualifiers |
|||
if not claimqualifs then |
|||
return nil |
|||
end |
|||
for i, qualif in pairs(qualifs) do |
|||
local vals = claimqualifs[qualif] |
|||
if vals and (vals[1].snaktype == 'value') then |
|||
return wd.getValue(vals[1]).time |
|||
end |
|||
end |
|||
end |
|||
local function chronosort(claims, inverted) |
|||
table.sort( |
|||
claims, |
|||
function(a,b) |
|||
local timeA = valinQualif(a, datequalifiers) or '' |
|||
local timeB = valinQualif(b, datequalifiers) or '' |
|||
if inverted then |
|||
return timeA > timeB -- only works after 10,000 BC |
|||
else |
|||
return timeB > timeA |
|||
end |
|||
end |
|||
) |
|||
return claims |
|||
end |
|||
local function atDate(claim, mydate) |
|||
if mydate == "today" then |
|||
mydate = os.date("!%Y-%m-%dT%TZ") |
|||
end |
|||
local newclaims = {} |
|||
local mindate = valinQualif(claim, {'P580'}) |
|||
local maxdate = valinQualif(claim, {'P582'}) |
|||
if modules.formatDate.before(mydate, mindate) and modules.formatDate.before(maxdate, mydate) then |
|||
return true |
|||
end |
|||
end |
|||
local function check(claim, condition) |
|||
if type(condition) == 'function' then -- cas standard |
|||
return condition(claim) |
|||
end |
|||
local msg = "args.condition should be a function" |
|||
return error(msg) |
|||
end |
|||
function wd.sortclaims(claims, sorttype) |
|||
if not claims then |
|||
return nil |
|||
end |
|||
if sorttype == 'chronological' then |
|||
return chronosort(claims) |
|||
elseif sorttype == 'inverted' then |
|||
return chronosort(claims, true) |
|||
elseif type(sorttype) == 'function' then |
|||
table.sort(claims, sorttype) |
|||
return claims |
|||
end |
|||
return claims |
|||
end |
|||
function wd.filterClaims(claims, args) --retire de la tables de claims celles qui sont éliminés par un des filters de la table des filters |
|||
local function filter(condition, filterfunction, funargs) |
|||
if not args[condition] then |
|||
return |
|||
end |
|||
for i = #claims, 1, -1 do |
|||
if not( filterfunction(claims[i], args[funargs[1]], args[funargs[2]], args[funargs[3]]) ) then |
|||
table.remove(claims, i) |
|||
end |
|||
end |
|||
end |
|||
filter('targetvalue', hastargetvalue, {'targetvalue'} ) |
|||
filter('isinlang', isinlanguage, {'isinlang'} ) |
|||
filter('atdate', atDate, {'atdate'} ) |
|||
filter('qualifier', wd.hasqualifier, {'qualifier', 'qualifiervalue'} ) |
|||
filter('excludequalifier', excludequalifier, {'excludequalifier', 'excludequalifiervalue'} ) |
|||
filter('withsource', hassource, {'withsource', 'sourceproperty'} ) |
|||
filter('withdate', hasdate, {} ) |
|||
filter('excludespecial', notSpecial, {} ) |
|||
filter('excludevalues', excludevalues, {'excludevalues'}) |
|||
filter('withlink', haslink, {'withlink', 'linklang'} ) |
|||
filter('condition', check, {'condition'}) |
|||
claims = withrank(claims, args.rank or 'best') |
|||
if args.sorttype then |
|||
claims = wd.sortclaims(claims, args.sorttype) |
|||
end |
|||
if #claims == 0 then |
|||
return nil |
|||
end |
|||
if args.numval then |
|||
claims = firstvals(claims, args.numval) |
|||
end |
|||
return claims |
|||
end |
|||
function wd.loadEntity(entity, cache) |
|||
if type(entity) ~= 'table' then |
|||
if cache then |
|||
if not cache[entity] then |
|||
cache[entity] = mw.wikibase.getEntity(entity) |
|||
mw.log("cached") |
|||
end |
|||
return cache[entity] |
|||
else |
|||
if entity == '' then |
|||
entity = nil |
|||
end |
|||
return mw.wikibase.getEntity(entity) |
|||
end |
|||
else |
|||
return entity |
|||
end |
|||
end |
|||
function wd.getClaims( args ) -- returns a table of the claims matching some conditions given in args |
|||
if args.claims then -- if claims have already been set, return them |
|||
return args.claims |
|||
end |
|||
local properties = wd.splitStr(args.property) |
|||
if not properties then |
|||
return error( 'property-param-not-provided' ) |
|||
end |
|||
--Get entity |
|||
local entity = args.entity |
|||
entity = wd.loadEntity(args.entity, args.cache) |
|||
if (not entity) or (not entity.claims) then |
|||
return nil |
|||
end |
|||
local claims = {} |
|||
for i, prop in pairs(properties) do |
|||
prop = string.upper(prop) |
|||
for j, claim in pairs(entity.claims[prop] or {}) do |
|||
table.insert(claims, claim) |
|||
end |
|||
end |
|||
if (#claims == 0) then |
|||
return nil |
|||
end |
|||
return wd.filterClaims(claims, args) |
|||
end |
|||
-------- |
|||
-- FORMATAGE ENTITES |
|||
function wd.getLabel(entity, lang, labelformat) |
|||
if (not entity) then |
|||
return nil -- ou option de gestion des erreurs ? |
|||
end |
|||
lang = lang or defaultlang |
|||
if type(labelformat) == 'function' then |
|||
return labelformat(entity) |
|||
end |
|||
if (type(entity) == 'string') and (lang == defaultlang) then -- le plus économique |
|||
local str = mw.wikibase.label(entity) |
|||
if str then -- mw.wikibase.label() ne fonctionne pas avec les redirect https://phabricator.wikimedia.org/T157868 |
|||
return str |
|||
end |
|||
end |
|||
if type(entity) == 'string' then |
|||
entity = mw.wikibase.getEntityObject(entity) |
|||
end |
|||
if entity and entity.labels and entity.labels[lang] then |
|||
return entity.labels[lang].value, true |
|||
end |
|||
end |
|||
function wd.formatEntity( entity, params ) |
|||
if (not entity) then |
|||
return nil --formatError('entity-not-found') |
|||
end |
|||
local id = entity |
|||
if type(id) == 'table' then |
|||
id = id.id |
|||
end |
|||
params = params or {} |
|||
local lang = params.lang or defaultlang |
|||
local speciallabels = params.speciallabels |
|||
local displayformat = params.displayformat |
|||
local labelformat = params.labelformat |
|||
local defaultlabel = params.defaultlabel or id |
|||
local linktype = params.link |
|||
local defaultlinktype = params.defaultlink |
|||
local defaultlinkquery = params.defaultlinkquery |
|||
if speciallabels and speciallabels[id] then --speciallabels override the standard label + link combination |
|||
return speciallabels[id] |
|||
end |
|||
if params.displayformat == 'raw' then |
|||
return id |
|||
end |
|||
local link, label |
|||
local str = '' -- l'intégralité du text à retourner |
|||
label = wd.getLabel(entity, lang, labelformat) |
|||
-- détermination du fait qu'on soit ou non en train de rendre l'élément sur la page de son article |
|||
local rendering_entity_on_its_page = wd.is_page_of_qid(id) |
|||
if not label then |
|||
if (defaultlabel == '-') then |
|||
return nil |
|||
end |
|||
link = wd.siteLink(id, 'wikidata') |
|||
return str .. '[[' .. link .. '|' .. id .. ']]' .. addcat(i18n['to translate']) |
|||
-- si pas de libellé, on met un lien vers Wikidata pour qu'on comprenne à quoi ça fait référence |
|||
end |
|||
if (linktype == '-') or rendering_entity_on_its_page then |
|||
return str .. label |
|||
end |
|||
local link = wd.siteLink(entity, linktype, lang) |
|||
if (not link) and defaultlinkquery then |
|||
defaultlinkquery.excludespecial = true |
|||
defaultlinkquery.entity = entity |
|||
if claims then |
|||
for i, j in pairs(claims) do |
|||
local id = wd.getMainId(j) |
|||
link = wd.siteLink(id, linktype, lang) |
|||
if link then |
|||
break |
|||
end |
|||
end |
|||
end |
|||
end |
|||
if link then |
|||
return str .. '[[' .. link .. '|' .. label .. ']]' |
|||
end |
|||
-- on est pas sur l'article de l'entité, et on a pas de lien de site |
|||
if (defaultlinktype ~= '-') then |
|||
local linktype |
|||
local sidelink, site, langcode |
|||
if defaultlinktype then |
|||
sidelink, site, langcode = wd.siteLink(entity, linktype, lang) |
|||
else |
|||
sidelink, site, langcode = wd.siteLink(entity, 'wiki', 'en') |
|||
end |
|||
if not sidelink then |
|||
sidelink, site = wd.siteLink(entity, 'wikidata') |
|||
end |
|||
local icon, class, title = site, nil, nil -- le texte affiché du lien |
|||
if site == 'wiki' then |
|||
icon, class, title = langcode, "indicateur-langue", translate('see-another-language', mw.language.fetchLanguageName(langcode, defaultlang)) |
|||
elseif site == 'wikidata' then |
|||
icon, class, title = 'd', "indicateur-langue", translate('see-wikidata') |
|||
else |
|||
title = translate('see-another-project', site) |
|||
end |
|||
local val = '[[' .. sidelink .. '|' .. '<span class = "' .. (class or '').. '" title = "' .. (title or '') .. '">' .. icon .. '</span>]]' |
|||
return str .. label .. '<small> (' .. val .. ')</small>' |
|||
end |
|||
return str .. label |
|||
end |
|||
function wd.addtrackingcat(prop, cat) -- doit parfois être appelé par d'autres modules |
function wd.addtrackingcat(prop, cat) -- doit parfois être appelé par d'autres modules |
||
Ligne 50 : | Ligne 752 : | ||
cat = translate('trackingcat', prop or 'P??') |
cat = translate('trackingcat', prop or 'P??') |
||
end |
end |
||
return |
return wd.addcat(cat ) |
||
end |
end |
||
Ligne 76 : | Ligne 778 : | ||
if type(str) ~= "string" then |
if type(str) ~= "string" then |
||
return |
return wd.formatError(snak.datatype) |
||
end |
end |
||
return str |
return str |
||
Ligne 88 : | Ligne 790 : | ||
return displayformat |
return displayformat |
||
end |
end |
||
return |
return wd.formatError() |
||
end |
end |
||
Ligne 108 : | Ligne 810 : | ||
for i, j in pairs( statement.qualifiers.P407 ) do |
for i, j in pairs( statement.qualifiers.P407 ) do |
||
if j.snaktype == 'value' then |
if j.snaktype == 'value' then |
||
local langentity = |
local langentity = wd.getId(j) |
||
local langcode = getlangcode(langentity) |
local langcode = getlangcode(langentity) |
||
table.insert(langlist, langcode) |
table.insert(langlist, langcode) |
||
Ligne 148 : | Ligne 850 : | ||
end |
end |
||
if not str then |
if not str then |
||
return |
return wd.formatError("adding qualifs to a nil str !")-- il y a un problème |
||
end |
end |
||
if statement.qualifiers.P1480 then |
if statement.qualifiers.P1480 then |
||
for i, j in pairs(statement.qualifiers.P1480) do |
for i, j in pairs(statement.qualifiers.P1480) do |
||
local v = |
local v = wd.getId(j) |
||
if (v == "Q21818619") then |
if (v == "Q21818619") then |
||
str = str .. " (ou environs)" |
str = str .. " (ou environs)" |
||
Ligne 227 : | Ligne 929 : | ||
local str |
local str |
||
local fuzzy = |
local fuzzy = wd.hasqualifier(statement, {"P1480"}, {"Q5727902"}) |
||
if fuzzy then |
if fuzzy then |
||
fuzzy = true |
fuzzy = true |
||
Ligne 351 : | Ligne 1 053 : | ||
accessdate = wd.formatSnak(ref.snaks.P813[1]) |
accessdate = wd.formatSnak(ref.snaks.P813[1]) |
||
end |
end |
||
s = modules.reference.citeitem( |
s = modules.reference.citeitem(wd.getId(source), {['page'] = page, ['accessdate'] = accessdate}) |
||
table.insert(refs, s) |
table.insert(refs, s) |
||
end |
end |
||
Ligne 364 : | Ligne 1 066 : | ||
-- publishdate avec P577 ? (ne semble pas vraiment correspondre) |
-- publishdate avec P577 ? (ne semble pas vraiment correspondre) |
||
if hasValue('P407') then |
if hasValue('P407') then |
||
local id = |
local id = wd.getId(ref.snaks.P407[1]) |
||
publishlang = getlangcode(id) |
publishlang = getlangcode(id) |
||
end |
end |
||
Ligne 398 : | Ligne 1 100 : | ||
if datatype == 'wikibase-item' then |
if datatype == 'wikibase-item' then |
||
return |
return wd.formatEntity(wd.getId(snak), params) |
||
end |
end |
||
Ligne 422 : | Ligne 1 124 : | ||
if datatype == 'time' then -- format example: +00000001809-02-12T00:00:00Z |
if datatype == 'time' then -- format example: +00000001809-02-12T00:00:00Z |
||
local precision = params.precision -- degré de précision à afficher ('day', 'month', 'year'), inférieur ou égal à value.precision |
|||
if displayformat == 'raw' then |
if displayformat == 'raw' then |
||
return value.time |
return value.time |
||
else |
else |
||
local dateobject = wd.dateobject(value, {precision = params.precision}) |
|||
return wd.objecttotext(dateobject, params) |
|||
end |
end |
||
end |
end |
||
Ligne 465 : | Ligne 1 167 : | ||
end |
end |
||
end |
end |
||
return |
return wd.formatError('unknown-datavalue-type' ) |
||
end |
end |
||
function wd.getClaims( args ) -- returns a table of the claims matching some conditions given in args |
|||
return modules.getData.getClaims(args) |
|||
end |
|||
function wd.stringTable(args) -- like getClaims, but get a list of string rather than a list of snaks, for easier manipulation |
function wd.stringTable(args) -- like getClaims, but get a list of string rather than a list of snaks, for easier manipulation |
||
Ligne 489 : | Ligne 1 186 : | ||
end |
end |
||
if args.removedupes and (args.removedupes ~= '-') then |
if args.removedupes and (args.removedupes ~= '-') then |
||
claims = |
claims = wd.addnewvalues({}, claims) -- devrait aussi supprimer de props celles qui ne sont pas utilisées |
||
end |
end |
||
return claims, props |
return claims, props |
||
Ligne 500 : | Ligne 1 197 : | ||
local vals = {} |
local vals = {} |
||
if type(qualifs) == 'string' then |
if type(qualifs) == 'string' then |
||
qualifs = |
qualifs = wd.splitStr(qualifs) |
||
end |
end |
||
for i, j in pairs(qualifs) do |
for i, j in pairs(qualifs) do |
||
Ligne 533 : | Ligne 1 230 : | ||
end |
end |
||
if type(qualifs) == 'string' then |
if type(qualifs) == 'string' then |
||
qualifs = |
qualifs = wd.splitStr(qualifs) |
||
end |
end |
||
local qualifargs = args.qualifargs or {} |
local qualifargs = args.qualifargs or {} |
||
Ligne 565 : | Ligne 1 262 : | ||
end |
end |
||
if not statement.type or statement.type ~= 'statement' then |
if not statement.type or statement.type ~= 'statement' then |
||
return |
return wd.formatError( 'unknown-claim-type' ) |
||
end |
end |
||
local prop = statement.mainsnak.property |
local prop = statement.mainsnak.property |
||
Ligne 620 : | Ligne 1 317 : | ||
return wd.getDatavalue( snak, params) |
return wd.getDatavalue( snak, params) |
||
else |
else |
||
return |
return wd.formatError( 'unknown-snak-type' ) |
||
end |
end |
||
end |
end |
||
Ligne 646 : | Ligne 1 343 : | ||
function wd.addLinkback(str, id, property) |
function wd.addLinkback(str, id, property) |
||
if not id then |
if not id then |
||
id = |
id = wd.getEntity() |
||
end |
end |
||
if not id then |
if not id then |
||
Ligne 704 : | Ligne 1 401 : | ||
return nil |
return nil |
||
end |
end |
||
args.entity = |
args.entity = wd.getEntity(args.entity) |
||
if args.grouped and args.grouped ~= '' then |
if args.grouped and args.grouped ~= '' then |
||
Ligne 721 : | Ligne 1 418 : | ||
end |
end |
||
if not props then |
if not props then |
||
props = |
props = wd.splitStr(args.property)[1] |
||
end |
end |
||
if args.ucfirst ~= '-' then |
if args.ucfirst ~= '-' then |
||
Ligne 740 : | Ligne 1 437 : | ||
if not qualifs then |
if not qualifs then |
||
return |
return wd.formatError( 'property-param-not-provided' ) |
||
end |
end |
||
if type(qualifs) == 'string' then |
if type(qualifs) == 'string' then |
||
qualifs = |
qualifs = wd.splitStr(qualifs) |
||
end |
end |
||
Ligne 805 : | Ligne 1 502 : | ||
function wd.Dump(entity) |
function wd.Dump(entity) |
||
entity = |
entity = wd.getEntity(entity) |
||
if not entity then |
if not entity then |
||
return |
return wd.formatError("entity-param-not-provided") |
||
end |
end |
||
return "<pre>"..mw.dumpObject(entity).."</pre>" |
return "<pre>"..mw.dumpObject(entity).."</pre>" |
||
Ligne 824 : | Ligne 1 521 : | ||
-- regroupe les affirmations par valeur de mainsnak |
-- regroupe les affirmations par valeur de mainsnak |
||
local function addClaim(claim) |
local function addClaim(claim) |
||
local id = |
local id = wd.getMainId(claim) |
||
for i, j in pairs(groupedClaims) do |
for i, j in pairs(groupedClaims) do |
||
if (j.id == id) then |
if (j.id == id) then |
||
Ligne 849 : | Ligne 1 546 : | ||
end |
end |
||
end |
end |
||
local qualifstr = modules.linguistic.conj(qualifs, " |
local qualifstr = modules.linguistic.conj(qualifs, "qualif-separator") |
||
if not qualifstr then |
if not qualifstr then |
||
return str |
return str |
Version du 2 septembre 2017 à 17:01
Module permettant d'utiliser de récupérer et de mettre en forme des données issues de Wikidata.
Dans la mesure du possible, ce module devrait être neutre sur le plan linguistique. Pour les textes spécifiquement français, voir Module:Wikidata/I18n.
Fonctions exportables
Fonctions opérant au niveau d'un snak
Nom | Arguments | Description |
---|---|---|
formatSnak | snak, params |
Récupère la valeur d'un snak et la met en forme |
getDataValue | snak, params |
Récupère la valeur d'un snak avec une valeur de type "value" et la met en forme |
isSpecial | snak |
retourne true si un snak est une valeur spéciale (novalue ou somevalue)
|
getId | snak |
retourne l'identifiant Qdd de l'élément utilisé comme valeur d'un snak |
Fonctions opérant au niveau d'une affirmation
Nom | Arguments | Description |
---|---|---|
formatStatement | params |
Transforme une déclaration individuelle en chaîne wikitexte, selon les mêmes paramètres que stringTable |
getDate | statement, qualifs |
récupère les informations de date stockées dans une déclaration Wikidata (qualificatifs ou valeur principale) et les stocke sous forme de table |
getFormattedDate | statement, params |
récupère la date associée à un déclaration Wikidata comme getDate, mais la retourne sous forme d'une chaîne formattée selon les paramètres params
|
hasQualifier | claim, acceptedqualifs, acceptedvals, excludequalifiervalues |
retourne true si l'affirmation comporte des qualificatifs utilisant les propriétés acceptedqualifs avec les valeurs acceptedvals, et sans les valeurs excludequalifiervalues. Si acceptedqualifs n'est pas renseignée, toutes les propriétés sont acceptées. Si acceptedvals n'est pas renseigné, toutes les valeurs sont acceptées.
|
getMainId | claim |
retourne l'identifiant Qdd de l'élément utilisé comme valeur du "mainsnak" d'une déclaration |
getFormattedQualifiers | statement, qualifs, params |
à partir d'une affirmation, retourne une chaîne contenant les qualificatifs demandés. La table params permet de personnaliser l'affichage, voir #Paramètres. |
getReferences | statement |
récupère et affiche la partie références d'une déclaration Wikidata. |
addTrackingCat | property, cat |
catégorise dans [[Catégorie:Page utilisant $property]] |
Fonctions opérant au niveau d'une entité
Nom | Arguments | Description |
---|---|---|
sortClaims | claims, sorttype |
Met en ordre une série de valeurs pour ordre chronologique ou de quantité, voir l'argument "sorttype" pour plus de détail. |
filterClaims | claims, params |
Prend une table d'affirmations, et exclut celles qui ne correspondent pas aux critères donnés dans la table params . Pour la liste de ces arguments, voir l'aide ci dessous
|
getClaims | params |
Retourne une table d'affirmations (ou nil) en fonction des instructions données dans la table params , qui dont contenir une clé |entity = et |property = , et peut contenir de nombreux autres paramètres optionnels, voir #Paramètres.
|
getIds | params |
Sélectionne des affirmations de la même manière que getClaims met au lieu de retourner les affirmations complètes, elle ne retourne que l'identifiant de son mainsnak (ne fonctionne que pour les données de type élément).
|
stringTable |
|
Retourne les mêmes affirmations que getClaims, sauf éventuellement celles supprimées par le paramètre removedupes. Chacune est rendue sous forme d'une chaîne en Wikitexte directement utilisable. Les paramètres de mise en forme sont également contenus dans la table params. |
formatStatements | params |
Retourne les mêmes valeurs que stringTable, mais concaténées sous forme de chaîne unique. La méthode de concaténation est définie par le paramètre conjtype qui utilise Module:Linguistique. Si les paramètres linkback et addcat sont activés, un rétrolien et une catégorie de maintenance peuvent également être ajoutés.
|
formatAndCat | params |
Même fonction que formatStatements , mais ajoute un rétrolien vers Wikidata et une catégorie de maintenance
|
getTheDate | params |
affiche une date qui se trouve soit en valeur principale soit en qualificatif de la propriété prop de l'élément item |
mainDate | entity |
Récupère et met en forme la "date principale" que l'on peut associer à l'élément, en fonction de ses propriétés P580 (« date de début »), P582 (« date de fin ») et P585 (« date ») |
keyDate | event, item, params |
Récupère et format une date provenant de l'élément item . event doit être soit un identifiant de propriété, dans ce cas là, la fonction récupérera les valeurs dans cette propriété, soit un identifiant d'élément. Dans ce cas là, elle cherchera cet élément dans les valeurs de P793 (« événement clé ») et retournera la date indiquée en qualificatif.event peut également être une liste d'identifiants sous forme de table, dans ce cas là, la valeur retournée sera celle du premier identifiant pour lequel quelque chose est trouvé. Par exemple wd.keyDate('Q1417098', 'P1690'} cherchera la valeur dans P793 (« événement clé ») Q1417098 (« inauguration ») et si elle ne trouve rien, elle cherchera dans P1690 (« ICD-10-PCS »).
|
getLabel | entity, lang1, lang2 |
Retourne le libellé Wikidata de l'entité en langue donnée par le code lang1 (français par défaut) ; si il est absent, le libellé en langue donnée par le code lang2 (par défaut, l'anglais ou la première langue de Module:Wikidata/Hiérarchie des langues ayant un libellé) et une catégorie de maintenance indiquant la langue utilisée. |
siteLink | entity, lang, project |
retourne un lien vers la page projet demandé ('wikipedia', 'wikivoyage', 'commons') etc. lié à l'entité Wikidata indiquée, dans la langue demandée. Par défaut, la langue est le français et le projet Wikpédia. |
formatEntity | entity, params |
Prend l'identifiant (ou la table de données) donnée en paramètre entité et la transforme, et la retourne sur la forme d'un texte contenant un libellé et éventuellement un lien interne. |
getDescription | entity, lang |
affiche la description Wikidata pour une entité donnée, dans un langue donnée (français par défaut) |
getNumericId | snak |
retourne l'identifiant numérique de l'élément utilisé comme valeur d'un snak |
getEntity | str |
retourne la table de données correpondant à un identifiant (inverse de getEntityId) |
getEntityId | str |
retourne l'identifiant d'une entité Wikidata passée sous la forme d'une table de données (inverse de getEntity) |
Fonctions récupérant des données dans plusieurs entités
Nom | Arguments | Description |
---|---|---|
isSubclass | class, item, maxdepth |
|
isinstance | class, item, maxdepth |
|
inTransitiveVals | searchedval, sourceval, query, maxdepth, maxnodes |
- Module:Wikidata/Chemin : Implémentation analogue aux PropertyPaths de SPARQL en Lua, plus de détails et exemples dans la page du module.
Nom | Arguments | Description |
---|---|---|
iterate | entité, chemin : iterateur |
retourne un itérateur sur toutes les valeurs possibles d’un chemin qui part de l’entité spécifiée. Exemple d’utilisation. |
matches | entité, chemin, valeur : |
retourne une valeur booléenne pour savoir si le chemin spécifié permet d’aller de l’entité « entité » à l’entité « valeur ». « isInstance » au-dessus est équilavente à path.matches(item, "P31/P279*", class) par exemple. Maxdepth pour l’instant pas implémenté, mais sans doute possible, il y a déjà une limite en dur dans les chemins).
|
Divers
Nom | Arguments | Descriptions |
---|---|---|
Dump | entity |
affiche le contenu d'une entité Wikidata |
sourceStr |
|
|
frameFun | (frame) | appelle une des fonctions précédentes depuis le frame. Le nom de la fonction est donné en argument 1 |
addRefAnchor |
|
|
addLinkback |
|
ajoute un rétrolien (généralement utilisé par formatStatements{linkback = true} , mais peut être utile comme fonction indépendante lorsque les données font l'objet de nombreuses manipulations avant leur rendu final
|
isHere | searchset, val |
retourne true si la chaîne val se trouve dans la table searchset
|
addNewValues | old, new |
ajoute les nouvelles valeurs à une table, seulement si elles ne s'y trouvent pas déjà |
Paramètres
Liste des clés pouvant être utilisées dans la table "params" mentionnée ci-dessous.
Choix des déclarations
Paramètres utilisés par la fonction filterclaims
et donc indirectement par les fonctions y faisant appel, tels que getClaims
et formatStatements
.
Nom | Mode d'utilisation | Description |
---|---|---|
claims | Lua | Liste de déclarations à utiliser. Lorsque ce paramètre est activé, les paramètres property et entity ne sont pas utilisés pour la récupération des données.
|
entity | Lua et wikicode | L'identifiant de l'entité Wikidata à utiliser. Par défaut, celle liée à la page. En Lua, on peut passer une entité déjà chargée plutôt que son identifiant. |
property | Lua et wikicode | Le nom de la propriété à utiliser, sous la forme property = PXX . En Lua, on peut utiliser plusieurs propriétés sous forme de tables
|
excludespecial | Lua et wikicode | Retire les déclarations dont la valeur principale (mainsnak) n'est pas de type "valeur", c'est-à-dire les déclarations "valeur inconnue" ou "aucune valeur".
En wikicode : activée par la |
targetvalue | Lua et wikicode | Ne retient que la ou les déclarations dont la valeur du snak principal correspond à la (ou une des) valeurs indiquées |
excludevalues | Lua et wikicode | Exclut les déclarations dont la valeur du snak principal correspond à la (ou une des) valeurs indiquées |
targetclass | Lua et wikicode | Ne retient que la ou les déclarations dont la valeur du snak principal est une instance de la (ou d'une des) classes indiquées, éventuellement via des sous-classes |
excludeclasses | Lua et wikicode | Exclut les déclarations dont la valeur du snak principal est une instance de la (ou d'une des) classes indiquées, éventuellement via des sous-classes |
targetsuperclass | Lua et wikicode | Ne retient que la ou les déclarations dont la valeur du snak principal est une sous-classe (éventuellement indirecte) de la (ou d'une des) classes indiquées |
excludesuperclasses | Lua et wikicode | Exclut les déclarations dont la valeur du snak principal est une sous-classe (éventuellement indirecte) de la (ou d'une des) classes indiquées |
qualifier | Lua et wikicode | Seules les déclarations contenant ce qualificatif son retournées. Pour activer l'affichage du qualificatif, voir showqualifiers
|
qualifiervalue | Lua et wikicode | Le qualificatif utilisé par l'argument qualifier doit avoir cette valeur (ou une de ces valeurs, s'il s'agit d'une table ou d'une liste de propriétés séparées par des virgules
|
excludequalifier | Lua et wikicode | Les déclarations contenant ce qualificatif sont exclues |
excludequalifiervalue | Lua et wikicode | Si ce paramètre est renseigné, excludequalifier n'est activé que lorsque la valeur du qualificatif se trouve dans celles qu'il indique.
|
withsource | Lua et wikicode | Ne retourne que les valeurs contenant une source, utilisant la source indiquée dans la propriété P248 (« affirmé dans »), ou une autre propriété définie par le paramètre sourceproperty . Pour accepter n'importe quelle source du moment qu'elle utilise la propriété demandée, mettre la valeur any . Pour désactiver ce paramètre, mettre la valeur - .
|
sourceproperty | Lua et wikicode | Propriété à utiliser pour le paramètre withsource
|
rank | Lua et wikicocde | Rangs acceptés :
Valeur par défaut : |
numval | Lua et wikicode | Nombre maximal de valeurs à retourner (les n premières valeurs de la liste établie par les autres paramètres) |
withlink | Lua et wikicode | Ne retourne que les valeurs contenant un lien vers le site spécifié. Si la valeur du paramètre est simplement true , le site utilisé sera Wikipédia en français.
|
withdate | Lua et wikicode | Ne retourne que les valeurs possédant un qualificatif de date : P585 (« date »), P580 (« date de début »), P582 (« date de fin ») |
atdate | Lua et wikicode | Exclut les valeurs dont les qualificatifs P580 (« date de début ») ou P582 (« date de fin ») indiquent qu'elle n'était pas valable à la période indiquée. atdate peut-être une date au format wikibase ou au format ISO. Les valeurs sans date ne sont pas exclues (elle peuvent l'être en ayant recours à la fonction withdate ). Pour demander la valeur à la date d'aujourd'hui utiliser : |atdate = today .
|
minprecision | Lua et Wikicode | Degré de précision minimum accepté pour les données de type date. Doit être une valeur numérique correspondant au modèle de Wikidata (par exemple année = 9) |
condition | Lua | Pour définir une fonction libre. Si la fonction retourne true , la déclaration sera gardée
|
sorttype | Lua et wikicode | Manière de classer les déclarations. Valeurs possibles :
|
Activation / désactivation de Wikidata
Nom | Mode d'utilisation | Description |
---|---|---|
value | Lua et wikicode | Lorsque le paramètre value est non vide, le module ne cherche pas les données de Wikidata, mais utilise celles fournies localement par ce paramètre. Les fonction formatAndCat en revanche lui applique linkback et addcat )
|
expl | Lua et wikicode | Lorsque le paramètre expl est présent, la fonction formatStatements ne fait rien si le paramètre value n'a pas la valeur résultat de {{WD}} (utile pour des données mises à jour mais dont l'utilité dans chaque article est difficile à décider automatiquement). |
Mise en forme des données
Nom | Niveau d'application | Mode d'utilisation | Description |
---|---|---|---|
conjtype | liste des déclarations | Lua et wikicode | La manière de coordonner les déclarations, en utilisant la fonction conj de Module:Linguistique. Valeurs possibles :
Toute autre valeur donnée au paramètre sera insérée entre chaque valeur ( |
qualifconjtype | snak | Lua et wikicode | Manière de coordonner les qualificatifs. Même fonctionnement que conjtype .
|
default | liste des déclarations | Lua et wikicode | Résultat par défaut à afficher si l'import depuis Wikidata donne un résultat vide. |
linkback | liste des déclarations | Lua et wikicode | Ajoute un rétrolien vers Wikidata sous forme d'un crayon « » |
addcat | liste des déclarations | Lua et wikicode | Met la page dans une catégorie de suivi (voir Catégorie:Page utilisant des données de Wikidata). Le nom de la catégorie correspond à la valeur du paramètre. Si cette valeur est simplement true , la catégorie est fonction du paramètre property.
Attention, ce paramètre peut être source de bugs. Par exemple, si la propriété est utilisée dans une url ou un lien. |
removedupes | choix des déclarations (à la fin, dans une fonction différente) |
Lua et wikicode | Lorsque, après toutes les mises en forme, deux déclarations sont rendues de la même manière, une seule est conservée. |
lang | mise en forme des données | Lua et Wikicode | Langue dans lequel le texte doit être retourné. |
snak (entité) | Lua et wikicode | Code Wikimédia de la langue utilisée pour afficher les libellés (par défaut : français) | |
wikidatalang | snak (entité) | Lua et Wikicode | Code Wikimédia de la langue utilisée pour afficher les libellés en l'absence du français (ou de lang) et de l'anglais. Par défaut, la première langue dont il existe un libellé dans la liste Module:Wikidata/Hiérarchie des langues. |
ucfirst | liste des déclarations | Lua et Wikicode | Par défaut, la fonction formatStatements ajoute une majuscule en début de texte. |ucfirst=- permet de désactiver cela.
|
statementformat | déclaration | Lua | doit être une fonction fonction(statement) return XX retournant une chaîne. Elle sera appliquée à sur chaque déclaration (permet de simplifier certaines infobox Lua)
|
showdate | déclaration | Lua et wikicode | Pour afficher la date entre parenthèses en petit pour chaque déclaration en utilisant les mêmes qualificatifs que (withdate). Lorsqu'aucune date n'est trouvée, la valeur est affichée sans aucune date. |
displayformat | snak | Lua et wikicode | Pour changer le format par défaut entre chaque valeur.
|
qualifdisplayformat | snak | Lua et wikicode | Format d'affichage des qualificatifs. Même fonctionnement que le paramètre displayformat . Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre displayformat comme la valeur principale.
|
showsource | déclaration | Lua et wikicode | Identifiant d'une source que l'on souhaiterait voir affichée en référence si elle est présente.
|
linktopic | snak (temporel) | Lua et wikicode | Type de lien à ajouter aux dates (voir Module:Date). Pour ne mettre aucun lien : linktopic = -
|
qualiflinktopic | snak (entité) | Lua et wikicode | Même fonctionnement que le paramètre linktopic , applicable aux qualificatifs. Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre linktopic comme la valeur principale.
|
precision | snak (temporel) | Lua et wikicode | Précision avec laquelle les dates doivent être affichées. Valeurs possibles :
Valeur par défaut : |
qualifprecision | snak | Lua et wikicode | Précision avec laquelle les qualificatifs temporels doivent être affichées. Même fonctionnement que precision .
|
textformat | snak (temporel) | Lua et wikicode | Format d'affichage des intervalles de temps, tels que définis par Module:Date complexe
|
speciallabels | snak (entité) | Lua | Tables de valeurs spéciales à utiliser à la place du libellé Wikidata pour la valeur de certains éléments, par exemple Module:Dictionnaire Wikidata/Métiers.female |
labelformat | snak (entité) | Lua et wikicode | (En Lua) fonction de mise en forme des libellés prenant comme argument un qid ; (en Lua ou en wikicode) l'une des chaînes de caractères suivantes :
En Lua, la valeur du paramètre peut aussi être une fonction applicable à un snak. |
labelformat2 | snak (entité) | Lua | Fonction de mise en forme des libellés prenant comme argument un libellé. |
qualiflabelformat | snak (entité) | Lua et wikicode | Mise en forme des libellés des qualificatifs. Même fonctionnement que le paramètre labelformat . Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre labelformat comme la valeur principale.
|
qualiflabelformat2 | snak (entité) | Lua et wikicode | Même fonctionnement que le paramètre qualiflabelformat appliqué à labelformat2 . Ce dédoublement est provisoire (26/09/22)
|
showlang | déclaration | Lua et wikicode | Lorsque la valeur principale est de type "texte monolingue", son code langue est affiché (utilisé par Module:Site officiel) |
showqualifiers | déclaration | Lua et wikicode | Qualificatif à retourner entre parenthèses derrière la valeur de la propriété principale demandée. En wikicode sous le format |showqualifiers = P460 , en Lua sous le format showqualifiers = "P460" ou showqualifiers = {"P460", "P461"}
|
showonlyqualifier | déclaration | Lua et wikicode | Qualificatif de même, mais à retourner seul sans la valeur de la propriété principale demandée |
link | snak (entité) | Lua et wikicode | Site vers lequel doivent lier les données de type élément. Par défaut : Wikidata en français. Si égal à "-", aucun lien ne sera créé. |
qualiflink | snak (entité) | Lua et wikicode | Site vers lequel doivent lier des qualificatifs. Même fonctionnement que le paramètre link . Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre link comme la valeur principale.
|
defaultlink | snak (entité) | Lua et wikicode | Lorsque le site demandé par le paramètre link ne retourne pas de lien, affiche un lien entre parenthèses vers le site demandé. Par défaut : Wikipédia en anglais ou, si absent, Wikidata. La valeur "-" désactive le paramètre. |
qualifdefaultlink | snak | Lua et wikicode | Même fonctionnement que defaultlink , applicable aux qualificatifs. Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre defaultlink comme la valeur principale.
|
defaultlinkquery | snak (entité) | Lua | defaultlinkquery = {property = 'P279'} le lien créé correspondra à celui fourni par l'élément utilisé dans la propriété P279 (« sous-classe de »). |
qualifdefaultlinkquery | snak | Lua et wikicode | Même fonctionnement que defaultlinkquery , applicable aux qualificatifs. Lorsque ce paramètre est laissé vide, les qualificatifs utilisent le paramètre defaultlinkquery comme la valeur principale.
|
targetunit | snak (quantité) | Lua et Wikicode | Unité dans laquelle doivent être converties les données de type quantité. Les valeurs possibles sont visibles dans Module:Conversion/Données, par exemple km ou km2. |
qualiftargetunit | snak | Lua et Wikicode | Unité dans laquelle doivent être converties les qualificatifs de type quantité. |
showunit | snak (quantité) | Lua et Wikicode |
Manière d'afficher l'unité demandée. Valeurs possibles :
défaut : 'short' |
rounding | snak (quantité) nombre de chiffres | Lua et Wikicode | Nombre de chiffres significatifs à afficher dans les données de type quantité, après conversion éventuelle (défaut : dépend de la précision indiquée sur Wikidata) |
urlpattern | snak (string) | Lua et wikicode | La valeur du paramètre est un chaîne représentant une URL, l'expression "$1" sera remplacée par la valeur Wikidata Avec la propriété P214 (« identifiant VIAF ») et la valeur de paramètre http://viaf.org/viaf/$1, la valeur de l'identifiant VIAF stockée sur Wikidata sera utilisée pour créer un lien externe.. |
text | snak (string) | Lua et wikicode | Texte à afficher lorsque la valeur crée un lien externe, c'est-à-dire pour les données de type chaîne avec displayformat = "weblink" ou avec le paramètre urlpattern renseigné. Par défaut : la valeur initiale de la déclaration. Utilisé sur Module:Site officiel Module:Bases archi.
|
novaluelabel | snak (novalue) | Lua et wikicode | Libellé à retourner lorsque la valeur est de type "novalue" (aucune valeur). Par défaut : "-". En Lua, la valeur peut-être une fonction. |
unknownlabel | snak (somevalue) | Lua et wikicode | Libellé à retourner lorsque la valeur est de type "somevalue" (valeur inconnue). Par défaut : "inconnu". En Lua, la valeur peut-être une fonction. |
returnnumberofvalues | liste des déclarations | Lua | retourne en deuxième valeur le nombre de valeurs récupérées par getClaims (si la fonction est appelée depuis du Wikicode, le nombre sera concaténé au reste de la chaîne retournée |
Exemples
Définition des liens
Code | Rendu | Remarques |
---|---|---|
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q79 | property = P36}} | Erreur de script : la fonction « frameFun » n’existe pas. | Capitale de l'Égypte, format standard |
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q79 | property = P36|link=-}} | Erreur de script : la fonction « frameFun » n’existe pas. | Capitale de l'Égypte, sans lien |
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q79 | property = P36|link=wikidata}} | Erreur de script : la fonction « frameFun » n’existe pas. | Capitale de l'Égypte, avec lien vers Wikidata |
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q937 | property = P569}} | Erreur de script : la fonction « frameFun » n’existe pas. | Date de naissance d'Albert Einstein, en utilisant le format standard de Wikipédia en français |
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q937 | property = P569|linktopic = football }} | Erreur de script : la fonction « frameFun » n’existe pas. | Date de naissance d'Einstein, avec liens spécialisés dans le football |
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q937 | property = P569|linktopic = -}} | Erreur de script : la fonction « frameFun » n’existe pas. | Date de naissance d'Einstein, sans lien |
Rang
Il existe trois types de rang sur Wikidata : "normal", "preferred" et "deprecated". Le rang deprecated est réservé aux données que l'on sait fausse mais que l'on garde pour mémoire, par exemple pour documenter une croyance ancienne qui a été infirmée par des études plus récentes.
Par défaut, seul le rang "preferred" est récupéré, mais le paramètre "rank" permet de changer cela.
Code | Rendu | Remarques |
---|---|---|
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186}} | Erreur de script : la fonction « frameFun » n’existe pas. | Matériau de la Joconde, affichage par défaut (donc seulement celles avec le rang "preferred" s'il y en a) |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|rank=valid}} | Erreur de script : la fonction « frameFun » n’existe pas. | rank = "valid" accepte les valeur de rang "normal" et "preferred" (par exemple, le matériau d'un chassis qui a été ajouté ultérieurement à la Joconde) |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|rank=normal}} | Erreur de script : la fonction « frameFun » n’existe pas. | rank = "normal" ne récupère que les données avec un rang "normal", et ignore celles avec un rang "preferred" |
Qualificatifs
Les qualificatifs sont des données supplémentaires intégrées à une affirmation Wikidata qu'elle permet de préciser.
Code | Rendu | Remarques |
---|---|---|
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|showqualifiers = P518}} | Erreur de script : la fonction « frameFun » n’existe pas. | ne retient que les valeurs ayant un qualificatif P518 (« s'applique à ») |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|qualifier = P518|qualifiervalue=Q1737943}} | Erreur de script : la fonction « frameFun » n’existe pas. | qualifiervalue définit la valeur que possède le qualificatif. Ici, Q1737943 (« châssis ») précise que l'on demande la matériau du chassis. Notez qu'aucune valeur de rang "preferred" n'étant trouvé, un valeur de rang "normal" est retournée. |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|showqualifiers = P518|rank=valid}} | Erreur de script : la fonction « frameFun » n’existe pas. | showqualifiers affiche la valeur des qualificatifs demandé entre parenthèse, après la valeur principale |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|showdate = true|rank=valid}} | Erreur de script : la fonction « frameFun » n’existe pas. | si des qualificatifs indiquant la date sont fournis, ils sont affichées |
Affichage des sources
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P276|sourceproperty = P854}} | Erreur de script : la fonction « frameFun » n’existe pas. | |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q11879536 | property = P460|withsource=Q1645493}} | Erreur de script : la fonction « frameFun » n’existe pas. | |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q11879536 | property = P460|withsource=Q1645493|showsource=true}} | Erreur de script : la fonction « frameFun » n’existe pas. | Montre seulement les valeurs données par la source |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q153 | property = P231|showsource=true}} | Erreur de script : la fonction « frameFun » n’existe pas. | |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q153 | property = P231|showsource=only}} | Erreur de script : la fonction « frameFun » n’existe pas. |
Autres options
Code | Rendu | Remarques |
---|---|---|
{{#invoke:Wikidata|frameFun|formatStatements|entity = Q937 | property = P106|conjtype = new line|showdate= true}} | Erreur de script : la fonction « frameFun » n’existe pas. | conjtype permet de définir le séparateur entre les valeurs (voir Module:Linguistique). Ici "new line" indique qu'il faut revenir à la ligne après chaque valeur. |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q205309 | property = P793|showdate=true|sorttype=chronological|conjtype =new line}} | Erreur de script : la fonction « frameFun » n’existe pas. | sorttype = chronological tente de classer les valeurs par ordre chronologique (en se basant sur les qualificatifs). Ici : les événements principaux (d:P:P793) dans l'histoire de l'ancien Stade d'Arsenal. |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q205309 | property = P793|showdate=true|sorttype=inverted|conjtype = new line}} | Erreur de script : la fonction « frameFun » n’existe pas. | sorttype = inverted pour inverser l'ordre chronologique |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q4470 | property = P50|showdate=true|sorttype=P1545|conjtype = new line}} | Erreur de script : la fonction « frameFun » n’existe pas. | sorttype = P1545 pour trié dans l'ordre de la série |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|displayformat=raw}} | Erreur de script : la fonction « frameFun » n’existe pas. | affiche les identifiants des valeurs (essentiellement utile pour la programmation) |
{{#invoke:Wikidata|frameFun|formatStatements|entity =Q12418 | property = P186|numval=1}} | Erreur de script : la fonction « frameFun » n’existe pas. | retourne les numval première valeurs répondant au reste de la requête (utile notamment pour récupérer une image) |
{{#invoke:Wikidata|frameFun|formatStatements|entity=Q535922 | property=P172 |expl= |value={{WD}} }} | Erreur de script : la fonction « frameFun » n’existe pas. | avec expl=, pour que la valeur soir retournée il faut value={{WD}} |
La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (modifier).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.
--script that retrieves basic data stored in Wikidata, for the datamodel, see https://www.mediawiki.org/wiki/Extension:Wikibase_Client/Lua
local wd = {}
local modules = { }
local modulesNames = {
reference = 'Module:Wikidata/Références',
linguistic = 'Module:Linguistique',
formatDate = 'Module:Date complexe',
formatNum = 'Module:Conversion',
langmodule = 'Module:Langue',
cite = 'Module:Biblio',
globes = 'Module:Wikidata/Globes',
langcodes = 'Module:Dictionnaire Wikidata/Codes langue', -- gros et rarement utilisé
weblink = 'Module:Weblink'
}
local function loadModule( t, key )
if modulesNames[key] then
local m = require( modulesNames[key] )
t[key] = m
return m
end
end
setmetatable( modules, { __index = loadModule } )
-- i18n
local defaultlang = mw.getContentLanguage():getCode()
wd.i18n = require "Module:Wikidata/I18n"
local function translate(str, rep1, rep2)
str = wd.i18n[str] or str
if rep1 then
str = str:gsub('$1', rep1)
end
if rep2 then
str = str:gsub('$2', rep2)
end
return str
end
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
function wd.isSpecial(snak)
return (snak.snaktype ~= 'value')
end
function wd.getId(snak)
if (snak.snaktype == 'value') then
return 'Q' .. snak.datavalue.value['numeric-id']
end
end
function wd.getNumericId(snak)
if (snak.snaktype == 'value') then
return snak.datavalue.value['numeric-id']
end
end
function wd.getMainId(claim)
return wd.getId(claim.mainsnak)
end
function wd.EntityId(entity)
if type(entity) == 'string' then
return entity
end
return entity.id
end
function wd.getValue(snak)
return snak.datavalue.value
end
-- function that returns true if the "qid" parameter is the qid
-- of the item that is linked to the calling page
function wd.is_page_of_qid(qid)
local entity_on_its_page = false
local self_entity = mw.wikibase.getEntity()
if self_entity ~= nil and qid == wd.EntityId(self_entity) then
entity_on_its_page = true
end
return entity_on_its_page
end
function wd.formatError( key , category, debug)
if debug then
return error(wd.i18n[key] or key)
end
if category then
return "[[Category:" .. category .. "|" .. (key or "") .. "]]"
else
return "[[Catégorie:Page avec un problème de codage Wikidata|" .. (key or "") .. "]]"
end
end
function wd.addcat(cat, sortkey)
if sortkey then
return '[[Category:' .. cat .. '|' .. (sortkey or '') .. ']]'
end
return '[[Category:' .. cat .. ']]'
end
function wd.getEntity( val )
if type(val) == 'table' then
return val
end
if val == '-' then
return nil
end
if val == '' then
val = nil
end
return mw.wikibase.getEntityObject(val)
end
function wd.splitStr(val) -- transforme en table les chaînes venant du Wikitexte qui utilisent des virgules de séparatin
if type(val) == 'string' then
val = mw.text.split(val, ",")
end
return val
end
function wd.isHere(searchset, val)
for i, j in pairs(searchset) do
if val == j then
return true
end
end
return false
end
function wd.getEntityPagename(entity)
if (not entity) then
return nil -- ou option de gestion des erreurs ?
end
local name ="d:"
if entity["type"] == "property" then
name = "d:Property:"
end
return name .. entity.id
end
function wd.getEntityPagename(entity)
if (not entity) then
return nil -- ou option de gestion des erreurs ?
end
local name ="d:"
if entity["type"] == "property" then
name = "d:Property:"
end
return name .. entity.id
end
local function wikidataLink(entity)
local name =':d:'
if type(entity) == 'string' then
if entity:match("P[0-9+]") then
entity = "Property:" .. entity
end
return name .. entity
elseif type(entity) == 'table' then
if entity["type"] == "property" then
name = ":d:Property:"
end
return name .. entity.id
elseif type(entity) == nil then
return formatError('entity-not-found')
end
end
function wd.siteLink(entity, project, lang)
-- returns 3 values: a sitelink (with the relevant prefix) a project name and a language
lang = lang or defaultlang
if (type(project) ~= 'string') then
project = 'wiki'
end
project = project:lower()
if project == 'wikipedia' then
project = 'wiki'
end
if type(entity) == 'string' and (project == 'wiki') and ( (not lang or lang == defaultlang) ) then -- évite de charger l'élément entier
return mw.wikibase.sitelink(entity), 'wiki', defaultlang
end
if project == 'wikidata' then
return wikidataLink(entity), 'wikidata'
end
local projects = {
-- nom = {préfixe sur Wikidata, préfix pour les liens sur Wikipédia, ajouter préfixe de langue}
wiki = {'wiki', nil, true}, -- wikipedia
commons = {'commonswiki', 'commons', false},
commonswiki = {'commonswiki', 'commons', false},
wikiquote = {'wikiquote', 'q', true},
wikivoyage = {'wikivoyage', 'voy', true},
wikibooks = {'wikibooks', 'b', true},
wikinews = {'wikinews', 'n', true},
wikiversity = {'wikiversity', 'v', true},
wikisource = {'wikisource', 's', true},
-- meta
-- mediawiki
}
entity = wd.getEntity(entity)
if not entity then
return nil
end
local projectdata = projects[project:lower()]
if not projectdata then -- sinon, on peut avoir des liens du type "enwiki" plutôt que "en" et lang = "wikipedia'
for k, v in pairs(projects) do
if project:match( k .. '$' )
and mw.language.isKnownLanguageTag(project:sub(1, #project-#k))
then
lang = project:sub(1, #project-#k)
projectdata = k
break
end
end
if not mw.language.isKnownLanguageTag(lang) then
return wd.formatError('invalid project code: ' .. (project or '?'))
end
end
if not projectdata then
return wd.formatError('invalid project code: ' .. (project or '?'))
end
local linkcode = projectdata[1]
local prefix = projectdata[2]
local multiversion = projectdata[3]
if multiversion then
linkcode = lang .. linkcode
end
local link = entity:getSitelink(linkcode)
if not link then
return nil
end
if prefix then
link = prefix .. ':' .. link
end
if multiversion then
link = ':' .. lang .. ':' .. link
end
return link, project, lang
end
-- add new values to a list, avoiding duplicates
function wd.addnewvalues(old, new)
if not new then
return old
end
for _, j in pairs(new) do
if not wd.isHere(old, j) then
table.insert(old, j)
end
end
return old
end
-- == FILTER CLAIMS ACCORDING TO VARIOUS CRITERIA : FUNCTION GETCLAIMS and affiliates
local function notSpecial(claim)
return (claim.mainsnak.snaktype == 'value')
end
local function hastargetvalue(claim, targets) -- retourne true si la valeur est dans la liste des target, ou si c'est une valeur spéciale filtrée séparément par excludespecial
local id = wd.getMainId(claim)
local targets = wd.splitStr(targets)
return wd.isHere(targets, id) or wd.isSpecial(claim.mainsnak)
end
local function excludevalues(claim, values) -- true si la valeur n'est pas dans la liste, ou si c'est une valeur spéciale (filtrée à part par excludespecial)
return wd.isSpecial(claim.mainsnak) or not ( hastargetvalue(claim, values) )
end
local function bestranked(claims)
if not claims then
return nil
end
local preferred, normal = {}, {}
for i, j in pairs(claims) do
if j.rank == 'preferred' then
table.insert(preferred, j)
elseif j.rank == 'normal' then
table.insert(normal, j)
end
end
if #preferred > 0 then
return preferred
else
return normal
end
end
local function withrank(claims, target)
if target == 'best' then
return bestranked(claims)
end
local newclaims = {}
for pos, claim in pairs(claims) do
if target == 'valid' then
if claim.rank ~= 'deprecated' then
table.insert(newclaims, claim)
end
elseif claim.rank == target then
table.insert(newclaims, claim)
end
end
return newclaims
end
function wd.hasqualifier(claim, acceptedqualifs, acceptedvals, excludequalifiervalues)
local claimqualifs = claim.qualifiers
if (not claimqualifs) then
return false
end
acceptedqualifs = wd.splitStr(acceptedqualifs)
acceptedvals = wd.splitStr( acceptedvals)
local function ok(qualif) -- vérification pour un qualificatif individuel
if not claimqualifs[qualif] then
return false
end
if not (acceptedvals) then -- si aucune valeur spécifique n'est demandée, OK
return true
end
for i, wanted in pairs(acceptedvals) do
for j, actual in pairs(claimqualifs[qualif]) do
if wd.getId(actual) == wanted then
return true
end
end
end
end
for i, qualif in pairs(acceptedqualifs) do
if ok(qualif) then
return true
end
end
return false
end
local function hassource(claim, targetsource, sourceproperty)
sourceproperty = sourceproperty or 'P248'
if targetsource == "-" then
return true
end
if (not claim.references) then return
false
end
local candidates = claim.references[1].snaks[sourceproperty] -- les snaks utilisant la propriété demandée
if (not candidates) then
return false
end
if (targetsource == "any") then -- si n'importe quelle valeur est acceptée tant qu'elle utilise en ref la propriété demandée
return true
end
targetsource = wd.splitStr(targetsource)
for _, source in pairs(candidates) do
local s = wd.getId(source)
for i, target in pairs(targetsource) do
if s == target then return true end
end
end
return false
end
local function excludequalifier(claim, qualifier, qualifiervalues)
return not wd.hasqualifier(claim, qualifier, qualifiervalues)
end
local function hasdate(claim)
local claimqualifs = claims.qualifiers
if not claimqualifs then
return false
end
for _, qualif in pairs(claimqualifs) do
if claimsqualifs[qualif] and claimsqualifs[qualif][1].snaktype == 'value' then
return true
end
end
return false
end
local function haslink(claim, site, lang)
if (claim.mainsnak.snaktype ~= 'value') then -- ne pas supprimer les valeurs spéciales, il y a une fonction dédiée pour ça
return true
end
local id = wd.getMainId(claim)
local link = wd.siteLink(id, site, lang)
if link then
return true
end
end
local function isinlanguage(claim, lang) -- ne fonctionne que pour les monolingualtext / étendre aux autres types en utilisant les qualifiers ?
if type(lang) == 'table' then -- si c'est une table de language séparées par des virgules, on les accepte toutes
for i, l in pairs(lang) do
local v = isinlanguage(claim, l)
if v then
return true
end
end
end
if type(lang) ~= ('string') then
return --?
end
if (lang == '-') then
return true
end
if (lang == 'locallang') then
lang = mw.getContentLanguage():getCode()
end
-- pour les monolingual text
local mainsnak = claim.mainsnak
if ( notSpecial(claim)) and mainsnak.datavalue.type == 'monolingualtext' then
if (mainsnak.datavalue.value.language == lang) then
return true
end
return false
end
-- pour les autres types de données : recherche dans les qualificatifs
if (lang == 'fr') then
lang = 'Q150'
elseif (lang == 'en') then
lang = 'Q1860'
else
lang = require "Module:Dictionnaire Wikidata/Codes langue/inversé"[lang]
end
if claim.qualifiers and claim.qualifiers.P407 then
if wd.hasqualifier(claim, {'P407'}, {lang}) then
return true
else
return false
end
end
return true -- si on ne ne sait pas la langue, on condière que c'est bon
end
local function firstvals(claims, numval) -- retourn les numval premières valeurs de la table claims
local numval = tonumber(numval) or 0 -- raise a error if numval is not a positive integer ?
if not claims then
return nil
end
while (#claims > numval) do
table.remove(claims)
end
return claims
end
local function valinQualif(claim, qualifs)
local claimqualifs = claim.qualifiers
if not claimqualifs then
return nil
end
for i, qualif in pairs(qualifs) do
local vals = claimqualifs[qualif]
if vals and (vals[1].snaktype == 'value') then
return wd.getValue(vals[1]).time
end
end
end
local function chronosort(claims, inverted)
table.sort(
claims,
function(a,b)
local timeA = valinQualif(a, datequalifiers) or ''
local timeB = valinQualif(b, datequalifiers) or ''
if inverted then
return timeA > timeB -- only works after 10,000 BC
else
return timeB > timeA
end
end
)
return claims
end
local function atDate(claim, mydate)
if mydate == "today" then
mydate = os.date("!%Y-%m-%dT%TZ")
end
local newclaims = {}
local mindate = valinQualif(claim, {'P580'})
local maxdate = valinQualif(claim, {'P582'})
if modules.formatDate.before(mydate, mindate) and modules.formatDate.before(maxdate, mydate) then
return true
end
end
local function check(claim, condition)
if type(condition) == 'function' then -- cas standard
return condition(claim)
end
local msg = "args.condition should be a function"
return error(msg)
end
function wd.sortclaims(claims, sorttype)
if not claims then
return nil
end
if sorttype == 'chronological' then
return chronosort(claims)
elseif sorttype == 'inverted' then
return chronosort(claims, true)
elseif type(sorttype) == 'function' then
table.sort(claims, sorttype)
return claims
end
return claims
end
function wd.filterClaims(claims, args) --retire de la tables de claims celles qui sont éliminés par un des filters de la table des filters
local function filter(condition, filterfunction, funargs)
if not args[condition] then
return
end
for i = #claims, 1, -1 do
if not( filterfunction(claims[i], args[funargs[1]], args[funargs[2]], args[funargs[3]]) ) then
table.remove(claims, i)
end
end
end
filter('targetvalue', hastargetvalue, {'targetvalue'} )
filter('isinlang', isinlanguage, {'isinlang'} )
filter('atdate', atDate, {'atdate'} )
filter('qualifier', wd.hasqualifier, {'qualifier', 'qualifiervalue'} )
filter('excludequalifier', excludequalifier, {'excludequalifier', 'excludequalifiervalue'} )
filter('withsource', hassource, {'withsource', 'sourceproperty'} )
filter('withdate', hasdate, {} )
filter('excludespecial', notSpecial, {} )
filter('excludevalues', excludevalues, {'excludevalues'})
filter('withlink', haslink, {'withlink', 'linklang'} )
filter('condition', check, {'condition'})
claims = withrank(claims, args.rank or 'best')
if args.sorttype then
claims = wd.sortclaims(claims, args.sorttype)
end
if #claims == 0 then
return nil
end
if args.numval then
claims = firstvals(claims, args.numval)
end
return claims
end
function wd.loadEntity(entity, cache)
if type(entity) ~= 'table' then
if cache then
if not cache[entity] then
cache[entity] = mw.wikibase.getEntity(entity)
mw.log("cached")
end
return cache[entity]
else
if entity == '' then
entity = nil
end
return mw.wikibase.getEntity(entity)
end
else
return entity
end
end
function wd.getClaims( args ) -- returns a table of the claims matching some conditions given in args
if args.claims then -- if claims have already been set, return them
return args.claims
end
local properties = wd.splitStr(args.property)
if not properties then
return error( 'property-param-not-provided' )
end
--Get entity
local entity = args.entity
entity = wd.loadEntity(args.entity, args.cache)
if (not entity) or (not entity.claims) then
return nil
end
local claims = {}
for i, prop in pairs(properties) do
prop = string.upper(prop)
for j, claim in pairs(entity.claims[prop] or {}) do
table.insert(claims, claim)
end
end
if (#claims == 0) then
return nil
end
return wd.filterClaims(claims, args)
end
--------
-- FORMATAGE ENTITES
function wd.getLabel(entity, lang, labelformat)
if (not entity) then
return nil -- ou option de gestion des erreurs ?
end
lang = lang or defaultlang
if type(labelformat) == 'function' then
return labelformat(entity)
end
if (type(entity) == 'string') and (lang == defaultlang) then -- le plus économique
local str = mw.wikibase.label(entity)
if str then -- mw.wikibase.label() ne fonctionne pas avec les redirect https://phabricator.wikimedia.org/T157868
return str
end
end
if type(entity) == 'string' then
entity = mw.wikibase.getEntityObject(entity)
end
if entity and entity.labels and entity.labels[lang] then
return entity.labels[lang].value, true
end
end
function wd.formatEntity( entity, params )
if (not entity) then
return nil --formatError('entity-not-found')
end
local id = entity
if type(id) == 'table' then
id = id.id
end
params = params or {}
local lang = params.lang or defaultlang
local speciallabels = params.speciallabels
local displayformat = params.displayformat
local labelformat = params.labelformat
local defaultlabel = params.defaultlabel or id
local linktype = params.link
local defaultlinktype = params.defaultlink
local defaultlinkquery = params.defaultlinkquery
if speciallabels and speciallabels[id] then --speciallabels override the standard label + link combination
return speciallabels[id]
end
if params.displayformat == 'raw' then
return id
end
local link, label
local str = '' -- l'intégralité du text à retourner
label = wd.getLabel(entity, lang, labelformat)
-- détermination du fait qu'on soit ou non en train de rendre l'élément sur la page de son article
local rendering_entity_on_its_page = wd.is_page_of_qid(id)
if not label then
if (defaultlabel == '-') then
return nil
end
link = wd.siteLink(id, 'wikidata')
return str .. '[[' .. link .. '|' .. id .. ']]' .. addcat(i18n['to translate'])
-- si pas de libellé, on met un lien vers Wikidata pour qu'on comprenne à quoi ça fait référence
end
if (linktype == '-') or rendering_entity_on_its_page then
return str .. label
end
local link = wd.siteLink(entity, linktype, lang)
if (not link) and defaultlinkquery then
defaultlinkquery.excludespecial = true
defaultlinkquery.entity = entity
if claims then
for i, j in pairs(claims) do
local id = wd.getMainId(j)
link = wd.siteLink(id, linktype, lang)
if link then
break
end
end
end
end
if link then
return str .. '[[' .. link .. '|' .. label .. ']]'
end
-- on est pas sur l'article de l'entité, et on a pas de lien de site
if (defaultlinktype ~= '-') then
local linktype
local sidelink, site, langcode
if defaultlinktype then
sidelink, site, langcode = wd.siteLink(entity, linktype, lang)
else
sidelink, site, langcode = wd.siteLink(entity, 'wiki', 'en')
end
if not sidelink then
sidelink, site = wd.siteLink(entity, 'wikidata')
end
local icon, class, title = site, nil, nil -- le texte affiché du lien
if site == 'wiki' then
icon, class, title = langcode, "indicateur-langue", translate('see-another-language', mw.language.fetchLanguageName(langcode, defaultlang))
elseif site == 'wikidata' then
icon, class, title = 'd', "indicateur-langue", translate('see-wikidata')
else
title = translate('see-another-project', site)
end
local val = '[[' .. sidelink .. '|' .. '<span class = "' .. (class or '').. '" title = "' .. (title or '') .. '">' .. icon .. '</span>]]'
return str .. label .. '<small> (' .. val .. ')</small>'
end
return str .. label
end
function wd.addtrackingcat(prop, cat) -- doit parfois être appelé par d'autres modules
if type(prop) == 'table' then
prop = prop[1] -- devrait logiquement toutes les ajouter
end
if not prop and not cat then
return error("no property provided")
end
if not cat then
cat = translate('trackingcat', prop or 'P??')
end
return wd.addcat(cat )
end
local function removeblanks(args)
for i, j in pairs(args) do
if j == '' then args[i] = nil end
end
return args
end
local function unknownvalue(snak, label)
local str = label
if type(str) == "function" then
str = str(snak)
end
if (not str) then
if snak.datatype == 'time' then
str = translate('sometime')
else
str = translate('somevalue')
end
end
if type(str) ~= "string" then
return wd.formatError(snak.datatype)
end
return str
end
local function novalue(displayformat)
if not displayformat then
return translate('novalue')
end
if type(displayformat) == 'string' then
return displayformat
end
return wd.formatError()
end
local function getlangcode(entityid)
return modules.langcodes[tonumber(entityid:sub(2))]
end
local function showlang(statement) -- retourne le code langue entre paranthèse avant la valeur (par exemple pour les biblios et liens externes)
local mainsnak = statement.mainsnak
if mainsnak.snaktype ~= 'value' then
return nil
end
local langlist = {}
if mainsnak.datavalue.type == 'monolingualtext' then
langlist = {mainsnak.datavalue.value.language}
elseif (not statement.qualifiers) or (not statement.qualifiers.P407) then
return
else
for i, j in pairs( statement.qualifiers.P407 ) do
if j.snaktype == 'value' then
local langentity = wd.getId(j)
local langcode = getlangcode(langentity)
table.insert(langlist, langcode)
end
end
end
if (#langlist > 1) or (#langlist == 1 and langlist[1] ~= defaultlang) then -- si c'est en français, pas besoin de le dire
return modules.langmodule.indicationMultilingue(langlist)
end
end
local function formattable(statements, params) -- transform a table of claims into a table of formatted values
for i, j in pairs(statements) do
j = wd.formatStatement(j, params)
end
return statements
end
function wd.tableToText(values, params) -- takes a list of already formatted values and make them a text
if not values then
return nil
end
-- filters out nil values to avoid error in subsequent table.concat
local filteredValues = {}
for i, v in ipairs(values) do
if v ~= nil then
table.insert(filteredValues, v)
end
end
return modules.linguistic.quickconj( filteredValues, params.conjtype)--modules.linguistic.conj( values, params.lang, params.conjtype )
end
function wd.addStandardQualifs(str, statement)
if (not statement) or (not statement.qualifiers) then
return str
end
if not str then
return wd.formatError("adding qualifs to a nil str !")-- il y a un problème
end
if statement.qualifiers.P1480 then
for i, j in pairs(statement.qualifiers.P1480) do
local v = wd.getId(j)
if (v == "Q21818619") then
str = str .. " (ou environs)"
elseif (v == "Q18122778") or (v == "Q18912752") then
str = str.. " (?)"
elseif (v == "Q5727902") then -- traité séparément, car plus complexe séparément
end
end
end
return str
end
function wd.rangeobject(begin, ending, params)
--[[
objet comportant un timestamp pour le classement chronologique et deux dateobject (begin et ending)
]]--
local timestamp
if begin then
timestamp = begin.timestamp
else
timestamp = ending.timestamp
end
return {begin = begin, ending = ending, timestamp = timestamp, type = 'rangeobject'}
end
function wd.dateobject(orig, params)
--[[ transforme un snak en un nouvel objet utilisable par Module:Date complexe
{type = 'dateobject', timestamp = str, era = '+' ou '-', year = number, month = number, day = number, calendar = calendar}
]]--
if not params then
params = {}
end
local newobj = modules.formatDate.splitDate(orig.time, orig.calendar)
newobj.precision = params.precision or orig.precision
newobj.type = 'dateobject'
return newobj
end
function wd.objecttotext(obj, params)
if obj.type == 'dateobject' then
return modules.formatDate.simplestring(obj, params)
elseif obj.type == 'rangeobject' then
return modules.formatDate.daterange(obj.begin, obj.ending, params)
end
end
local function getDatefromQualif(statement, qualif)
if (not statement) or (not statement.qualifiers) or not (statement.qualifiers[qualif]) then
return nil
end
local v = statement.qualifiers[qualif][1]
if v.snaktype ~= 'value' then -- que faire dans ce cas ?
return nil
end
return wd.dateobject(v.datavalue.value)
end
function wd.getDate(statement)
local period = getDatefromQualif(statement, 'P585') -- retourne un dateobject
if period then
return period
end
local begin, ending = getDatefromQualif(statement, 'P580'), getDatefromQualif(statement, 'P582')
if begin or ending then
return wd.rangeobject(begin, ending) -- retourne un rangeobject fait de deux dateobject
end
end
function wd.getFormattedDate(statement, params, useallqualifiers)
if not statement then
return nil
end
local str
local fuzzy = wd.hasqualifier(statement, {"P1480"}, {"Q5727902"})
if fuzzy then
fuzzy = true
end
--cherche la date avec les qualifs P580/P582
local datetable = wd.getDate(statement)
if datetable then
str = wd.objecttotext(datetable, params)
end
-- puis limite intérieur / supérieur
if not str then
local start, ending = getDatefromQualif(statement, 'P1319'), getDatefromQualif(statement, 'P1326')
str = modules.formatDate.between(start, ending, params)
end
-- sinon, le mainsnak, pour les données de type time
if (not str) and (statement.mainsnak.datatype == 'time') then
local mainsnak = statement.mainsnak
if
(mainsnak.snaktype == 'value' and mainsnak.datavalue.value.precision > 7)
or
(mainsnak.snaktype == 'somevalue')
then
str = wd.formatSnak(mainsnak, params)
end
end
-- ajouter le qualificatif "environ"
if fuzzy then
str = modules.formatDate.fuzzydate(str)
end
-- autres valeurs de qualité de l'information
if str and (useallqualifiers ~= "-") then
str = wd.addStandardQualifs(str, statement)
if params.showqualifiers then
str = wd.showQualifiers(str, statement, params)
end
end
return str
end
-- Fonction qui trie des Claims de type time selon l'ordre chronologique
-- Une clé de tri nomée « dateSortKey » est ajouté à chaque claim.
-- Si des clés de tri de ce nom existent déjà, elles sont utilisées sans modification.
function wd.sortDateClaims( claims )
for _, claim in ipairs( claims ) do
if not claim.dateSortKey then
local iso = wd.formatSnak( claim.mainsnak, { displayformat = 'raw' } )
-- transformation en nombre (indication de la base car gsub retourne deux valeurs)
iso = tonumber( iso:gsub( '(%d)%D', '%1' ), 10 ) or 0
claim.dateSortKey = iso
end
end
table.sort(
claims,
function ( c1, c2 )
return c1.dateSortKey < c2.dateSortKey
end
)
end
function wd.wikidataDate(prop, item, params)
local claims = wd.getClaims{entity = item, property = prop}
if not claims then
return nil
end
wd.sortDateClaims( claims )
params = params or {}
local vals = {}
for i, j in ipairs(claims) do
local v = wd.getFormattedDate(j, params)
if v then
table.insert(vals, v)
end
end
local str = modules.linguistic.conj(vals, params.conjtype or 'or')
if not str then
return
end
if params.addcat ~= '-' then
str = str .. wd.addtrackingcat(prop)
end
if params.linkback ~= '-' then
str = wd.addLinkback(str, item, prop)
end
return str
end
function wd.getReferences(statement)
local refdata = statement.references
if not refdata then
return nil
end
local function firstsnak(prop)
return wd.formatSnak(prop[1])
end
local refs = {}
for i, ref in pairs(refdata) do
local s
local function hasValue(prop) -- checks that the prop is here with valid value
if ref.snaks[prop] and ref.snaks[prop][1].snaktype == 'value' then
return true
end
return false
end
if ref.snaks.P248 then
for j, source in pairs(ref.snaks.P248) do
if source.snaktype == 'value' then
local page, accessdate
if hasValue('P304') then
page = wd.formatSnak(ref.snaks.P304[1])
end
if hasValue('P813') then
accessdate = wd.formatSnak(ref.snaks.P813[1])
end
s = modules.reference.citeitem(wd.getId(source), {['page'] = page, ['accessdate'] = accessdate})
table.insert(refs, s)
end
end
elseif hasValue('P854') and hasValue('P1476') then
local url, title, accessdate, publishdate, publishlang
url, title = wd.formatSnak(ref.snaks.P854[1], {text = "-"}), wd.formatSnak(ref.snaks.P1476[1])
if hasValue('P813') then
accessdate = wd.formatSnak(ref.snaks.P813[1])
end
-- publishdate avec P577 ? (ne semble pas vraiment correspondre)
if hasValue('P407') then
local id = wd.getId(ref.snaks.P407[1])
publishlang = getlangcode(id)
end
s = modules.cite.lienWeb{titre = title, url = url, langue = publishlang, ['en ligne le'] = publishdate, ['consulté le'] = accessdate}
table.insert(refs, s)
elseif ref.snaks.P854 and ref.snaks.P854[1].snaktype == 'value' then
s = wd.formatSnak(ref.snaks.P854[1], {text = "-"})
table.insert(refs, s)
end
end
if #refs > 0 then
return refs
end
end
function wd.getDatavalue(snak, params)
if not params then
params = {}
end
local speciallabels = params.speciallabels -- parfois on a besoin de faire une liste d'éléments pour lequel le libellé doit être changé, pas très pratique d'utiliser une fonction pour ça
if snak.snaktype ~= 'value' then
return nil
end
local datatype = snak.datatype
local value = snak.datavalue.value
local displayformat = params.displayformat
if type(displayformat) == 'function' then
return displayformat(snak, params)
end
if datatype == 'wikibase-item' then
return wd.formatEntity(wd.getId(snak), params)
end
if datatype == 'url' then
return modules.weblink.makelink(value, params.text)
end
if datatype == 'math' then
return mw.getCurrentFrame():extensionTag( "math", value)
end
if (datatype == 'string') or (datatype == 'external-id') or (datatype == 'commonsMedia') then -- toutes les données de type string sauf "math"
if params.urlpattern then
local urlpattern = params.urlpattern
if type(urlpattern) == 'function' then
urlpattern = urlpattern(value)
end
local url = mw.ustring.gsub(urlpattern, '$1', (value:gsub('%%', '%%%%'))):gsub(' ', '%%20')
value = '[' .. url .. ' ' .. (params.text or value) .. ']'
end
return value
end
if datatype == 'time' then -- format example: +00000001809-02-12T00:00:00Z
if displayformat == 'raw' then
return value.time
else
local dateobject = wd.dateobject(value, {precision = params.precision})
return wd.objecttotext(dateobject, params)
end
end
if datatype == 'globe-coordinate' then
-- retourne une table avec clés latitude, longitude, précision et globe à formater par un autre module (à changer ?)
if displayformat == 'latitude' then
return value.latitude
elseif displayformat == 'longitude' then
return value.longitude
else
local coordvalue = mw.clone( value )
coordvalue.globe = modules.globes[value.globe] -- transforme l'ID du globe en nom anglais utilisable par geohack
return coordvalue -- note : les coordonnées Wikidata peuvent être utilisée depuis Module:Coordinates. Faut-il aussi autoriser à appeler Module:Coordiantes ici ?
end
end
if datatype == 'quantity' then -- todo : gérer les paramètre précision
local amount, unit = value.amount, value.unit
if unit then
unit = unit:match('Q%d+')
end
local raw
if displayformat == "raw" then
raw = true
end
return modules.formatNum.displayvalue(amount, unit,
{targetunit = params.targetunit, raw = raw, rounding = params.rounding, showunit = params.showunit or 'short', showlink = params.showlink}
)
end
if datatype == 'monolingualtext' then
if value.language == defaultlang then
return value.text
else
return modules.langmodule.langue({value.language, value.text})
end
end
return wd.formatError('unknown-datavalue-type' )
end
function wd.stringTable(args) -- like getClaims, but get a list of string rather than a list of snaks, for easier manipulation
local claims = args.claims
if not claims then
claims = wd.getClaims(args)
end
if not claims or claims == {} then
return nil
end
local props = {} -- liste des propriétés associété à chaque string pour catégorisation et linkback
for i, j in pairs(claims) do
claims[i] = wd.formatStatement(j, args)
table.insert(props, j.mainsnak.property)
end
if args.removedupes and (args.removedupes ~= '-') then
claims = wd.addnewvalues({}, claims) -- devrait aussi supprimer de props celles qui ne sont pas utilisées
end
return claims, props
end
function wd.getQualifiers(statement, qualifs, params)
if not statement.qualifiers then
return nil
end
local vals = {}
if type(qualifs) == 'string' then
qualifs = wd.splitStr(qualifs)
end
for i, j in pairs(qualifs) do
if statement.qualifiers[j] then
for k, l in pairs(statement.qualifiers[j]) do
table.insert(vals, l)
end
end
end
if #vals == 0 then
return nil
end
return vals
end
function wd.getFormattedQualifiers(statement, qualifs, params)
if not params then params = {} end
local qualiftable = wd.getQualifiers(statement, qualifs)
if not qualiftable then
return nil
end
for i, j in pairs(qualiftable) do
qualiftable[i] = wd.formatSnak(j, params)
end
return modules.linguistic.conj(qualiftable, params.conjtype)
end
function wd.showQualifiers(str, statement, args) -- utilisée par formatStatement et par wikidatadate
local qualifs = args.showqualifiers
if not qualifs then
return str -- or error ?
end
if type(qualifs) == 'string' then
qualifs = wd.splitStr(qualifs)
end
local qualifargs = args.qualifargs or {}
-- formatage des qualificatifs = args commençant par "qualif", ou à défaut, les mêmes que pour la valeur principale
qualifargs.displayformat = args.qualifdisplayformat or args.displayformat
qualifargs.labelformat = args.qualiflabelformat or args.labelformat
qualifargs.link = args.qualiflink or args.link
qualifargs.conjtype = args.qualifconjtype
local formattedqualifs = wd.getFormattedQualifiers(statement, qualifs, qualifargs)
if formattedqualifs and str then
str = str .. modules.linguistic.inparentheses(formattedqualifs, defaultlang)
end
return str
end
function wd.sourceStr(sources)
if not sources or (#sources == 0) then
return nil
end
for i, j in pairs(sources) do
sources[i] = mw.getCurrentFrame():extensionTag( "ref", j)
end
return table.concat(sources, '<sup class="reference cite_virgule">,</sup>')
end
function wd.formatStatement( statement, args )
if not args then
args = {}
end
if not statement.type or statement.type ~= 'statement' then
return wd.formatError( 'unknown-claim-type' )
end
local prop = statement.mainsnak.property
local str
-- partie principale
if args.showonlyqualifier and (args.showonlyqualifier ~= '') then
str = wd.getFormattedQualifiers(statement, args.showonlyqualifier, args)
if not str then
return nil
end
elseif args.statementformat and (type(args.statementformat) == 'function') then
str = args.statementformat(statement, args)
else
str = wd.formatSnak( statement.mainsnak, args )
end
-- ajouts divers
if args.showlang == true then
str = (showlang(statement) or '') .. ' ' .. str
end
if args.showqualifiers then
str = wd.showQualifiers(str, statement, args)
end
if args.showdate then -- when "showdate and chronosort are both set, date retrieval is performed twice
local period = wd.getFormattedDate(statement, args, "-") -- 3 arguments indicate the we should not use additional qualifiers, alrady added by wd.formatStatement
if period then
str = str .. " <small>(" .. period ..")</small>"
end
end
if args.showsource then
local sources = wd.getReferences(statement)
if sources then
local source = wd.sourceStr(sources)
str = str .. (source or "")
end
end
if statement.qualifiers then
str = wd.addStandardQualifs(str, statement)
end
return str
end
function wd.formatSnak( snak, params )
if not params then params = {} end -- pour faciliter l'appel depuis d'autres modules
if snak.snaktype == 'somevalue' then
return unknownvalue(snak, params.unknownlabel)
elseif snak.snaktype == 'novalue' then
return novalue(params.novaluelabel)
elseif snak.snaktype == 'value' then
return wd.getDatavalue( snak, params)
else
return wd.formatError( 'unknown-snak-type' )
end
end
function wd.getDescription(entity, lang)
lang = lang or defaultlang
local description
if lang == defaultlang then
return mw.wikibase.descriptionl(qid)
end
if not entity.descriptions then
return translate('no description')
end
local descriptions = entity.descriptions
if not descriptions then
return nil
end
if descriptions[lang] then
return descriptions[delang].value
end
return entity.id
end
function wd.addLinkback(str, id, property)
if not id then
id = wd.getEntity()
end
if not id then
return str
end
if type(property) == 'table' then
property = property[1]
end
if type(id) == 'table' then
id = id.id
end
local class = ''
if property then
class = 'wd_' .. string.lower(property)
end
local icon = '[[File:Blue pencil.svg|%s|10px|baseline|class=noviewer|link=%s]]'
local title = translate('see-wikidata-value')
local url = mw.uri.fullUrl('d:' .. id, 'uselang=fr')
url.fragment = property -- ajoute une #ancre si paramètre "property" défini
url = tostring(url)
local v = mw.html.create('span')
:addClass(class)
:wikitext(str)
:tag('span')
:addClass('noprint wikidata-linkback')
:css('padding-left', '0.5em')
:wikitext(icon:format(title, url))
:allDone()
return tostring(v)
end
function wd.addRefAnchor(str, id)
--[[
Insère une ancre pour une référence générée à partir d'un élément wd.
L'id Wikidata sert d'identifiant à l'ancre, à utiliser dans les modèles type "harvsp"
--]]
return tostring(
mw.html.create('span')
:attr('id', id)
:attr('class', "ouvrage")
:wikitext(str)
)
end
function wd.formatStatements( args )--Format statement and concat them cleanly
if args.value == '-' then
return nil
end
local valueexpl = translate("activate-query")
--If a value is already set, use it
if args.value and (args.value ~= '') and (args.value ~= valueexpl) then
return args.value
end
-- if args.expl: return something only one if explicitly required in Wikitext
if args.expl and (args.value ~= valueexpl) then
return nil
end
args.entity = wd.getEntity(args.entity)
if args.grouped and args.grouped ~= '' then
args.grouped = false
return wd.groupedStatements(args)
end
local valuetable = args.valuetable -- dans le cas où les valeurs sont déjà formtées
local props -- les prorpriétés réellement utilisées (dans certainse cas, ce ne sont pas toutes celles de ags.property
if not valuetable then -- cas le plus courant
valuetable, props = wd.stringTable(args)
end
local str = wd.tableToText(valuetable, args)
if not str then
return nil
end
if not props then
props = wd.splitStr(args.property)[1]
end
if args.ucfirst ~= '-' then
str = modules.linguistic.ucfirst(str)
end
if args.addcat and (args.addcat ~= '-') then
str = str .. wd.addtrackingcat(props)
end
if args.linkback and (args.linkback ~= '-') then
str = wd.addLinkback(str, args.entity, props)
end
return str
end
function wd.showQualifier( args )
local qualifs = args.qualifiers or args.qualifier
if not qualifs then
return wd.formatError( 'property-param-not-provided' )
end
if type(qualifs) == 'string' then
qualifs = wd.splitStr(qualifs)
end
local claims = wd.getClaims(args)
if not claims then
return nil
end
local str = ''
for i, j in pairs(claims) do
local new = wd.getFormattedQualifiers(j, qualifs, args) or ''
str = str .. new
end
return str
end
function wd.formatAndCat(args)
if not args then
return nil
end
args.linkback = args.linkback or true
args.addcat = true
if args.value then -- do not ignore linkback and addcat, as formatStatements do
local val = args.value .. wd.addtrackingcat(args.property)
val = wd.addLinkback(val, args.entity, args.property)
return val
end
return wd.formatStatements( args )
end
function wd.getTheDate(args)
local claims = wd.getClaims(args)
if not claims then
return nil
end
local formattedvalues = {}
for i, j in pairs(claims) do
local v = wd.getFormattedDate(j, args)
if v then
table.insert(formattedvalues, v )
end
end
local val = modules.linguistic.conj(formattedvalues)
if not val then
return nil
end
if args.addcat == true then
val = val .. wd.addtrackingcat(args.property)
end
val = wd.addLinkback(val, args.entity, args.property)
return val
end
-- Complex functions using several items
local function getids(query)
query.excludespecial = true
query.displayformat = 'raw'
return wd.stringTable(query)
end
function wd.Dump(entity)
entity = wd.getEntity(entity)
if not entity then
return wd.formatError("entity-param-not-provided")
end
return "<pre>"..mw.dumpObject(entity).."</pre>"
end
function wd.groupedStatements(args, type)
-- regroupe les affirmations ayant la même valeur en mainsnak, mais des qualificatifs différents
-- (seulement pour les propriétés de type élément)
local claims = wd.getClaims(args)
if not claims then
return nil
end
local groupedClaims = {}
-- regroupe les affirmations par valeur de mainsnak
local function addClaim(claim)
local id = wd.getMainId(claim)
for i, j in pairs(groupedClaims) do
if (j.id == id) then
table.insert(groupedClaims[i].claims, claim)
return
end
end
table.insert(groupedClaims, {id = id, claims = {claim}})
end
for i, claim in pairs(claims) do
addClaim(claim)
end
local stringTable = {}
-- instructions ad hoc pour les paramètres concernant la mise en forme d'une déclaration individuelle
local funs = {
{param = "showqualifiers", fun = function(str, claims)
local qualifs = {}
for i, claim in pairs(claims) do
local news = wd.getFormattedQualifiers(claim, args.showqualifiers, args)
if news then
table.insert(qualifs, news)
end
end
local qualifstr = modules.linguistic.conj(qualifs, "qualif-separator")
if not qualifstr then
return str
end
return str .. " " .. modules.linguistic.inparentheses(qualifstr)
end
},
{param = "showdate", fun = function(str, claims)
-- toutes les dates sont regroupées à l'intérieur des mêmes parenthèses ex "médaille d'or (1922, 1924)"
local dates = {}
for i, statement in pairs(claims) do
local s = wd.getFormattedDate(statement, args, true) -- l'option useallqualifiers ne doit pas être désactivée dans ce cas
if statement then table.insert(dates, s) end
end
local datestr = modules.linguistic.conj(dates)
if not datestr then
return str
end
return str .. "<small>" .. modules.linguistic.inparentheses(datestr) .. "</small>"
end
},
{param = "showsource", fun = function(str, claims)
-- les sources sont toutes affichées au même endroit, à la fin
-- si deux affirmations ont la même source, on ne l'affiche qu'une fois
local sources = {}
local function dupeRef(old, new)
for i, j in pairs(old) do
if j == new then
return true
end
end
end
for i, claim in pairs(claims) do
local refs = wd.getReferences(claim)
if refs then
for i, j in pairs(refs) do
if not dupeRef(sources, j) then
table.insert(sources, j)
end
end
end
end
return str .. (wd.sourceStr(sources) or "")
end
}
}
for i, group in pairs(groupedClaims) do -- bricolage pour utiliser les arguments de formatStatements
local str = wd.formatEntity(group.id, args)
for i, fun in pairs(funs) do
if args[fun.param] then
str = fun.fun(str, group.claims, args)
end
end
table.insert(stringTable, str)
end
args.valuetable = stringTable
return wd.formatStatements(args)
end
return wd