Modulo:Wikidata

Istruzioni per l'uso
Questo è un modulo scritto in Lua. Le istruzioni che seguono sono contenute nella sottopagina Modulo:Wikidata/man (modifica · cronologia)
Sandbox: Modulo:Wikidata/sandbox (modifica · cronologia) · Test: Modulo:Wikidata/test (modifica · cronologia · Esegui)

Il modulo Wikidata implementa le funzionalità dei template {{Wikidata}}, {{WikidataQ}}, {{WikidataIdx}}, {{WikidataN}}, {{WikidataLabel}}, {{WikidataLink}} e {{WikidataProp}}.

Utilizzo da un altro modulo

Il modulo può essere usato anche da un altro modulo tramite "require". È sufficiente inserire all'inizio del modulo:

local mWikidata = require('Modulo:Wikidata')

Le funzioni hanno gli stessi nomi ma con un underscore iniziale.

Esempio

local mWikidata = require('Modulo:Wikidata')
local p = {}

function p.main(frame)
	local capitale, data, stati, italia, onu

	-- utilizzo della funzione getProperty
	capitale = mWikidata._getProperty( { 'P36', from = 'Q183' } )
	-- utilizzo della funzione getQualifier
	data = mWikidata._getQualifier( { 'P36', 'P580', from = 'Q183' } )
	-- utilizzo della funzione N
	stati = mWikidata._N( { 'P47', from = 'Q183' } )
	-- utilizzo della funzione indexOf
	italia = mWikidata._indexOf( { 'P47', 'Q38', from = 'Q183' } )
	-- utilizzo della funzione instanceOf
	onu = mWikidata._instanceOf( { 'Q160016', from = 'Q183' } )

	return string.format('La capitale della Germania è %s, dal %s. ' .. 
						 'Confina con %s Stati, con l\'Italia: %s. ' ..
						 'Membro delle Nazioni Unite: %s.',
						 capitale, data, stati, italia == -1 and 'no' or 'sì', onu and 'sì' or 'no') 
end

return p

---

--[[
* Modulo per implementare le funzionalità dei template:
* {{Wikidata}}, {{WikidataQ}}, {{WikidataIdx}}, {{WikidataN}},
* {{WikidataLabel}}, {{WikidataLink}}, {{WikidataTipo}} e {{WikidataId}}.
* Permette di accedere a Wikidata in modo più avanzato rispetto a {{#property}}.

* Il modulo è stato importato da:
* https://it.wikipedia.org/w/index.php?title=Modulo:Wikidata&oldid=78797880
* che a sua volta è una riscrittura e ampliamento a partire da:
* http://test2.wikipedia.org/w/index.php?title=Module:Wikidata&oldid=52322
]]

require('strict')

local getArgs = require('Module:Arguments').getArgs
local mConvert = require('Module:Conversione')
local mLanguages = require('Module:Linguaggi')

-- Categoria per le pagine con errori
local errorCategory = '[[Categoria:Voci con errori del modulo Wikidata]]'

local p = {}

-- Messaggi di errore
local i18n = {
	["errors"] = {
		["entityid-param-not-provided"] = "Parametro ''entityid'' non fornito",
		["property-param-not-provided"] = "Parametro ''property'' non fornito",
		["qualifier-param-not-provided"] = "Parametro ''qualifier'' non fornito",
		["value-param-not-provided"] = "Parametro ''valore'' da ricercare non fornito",
		["entity-not-found"] = "Entità non trovata",
		["unknown-claim-type"] = "Tipo asserzione sconosciuta",
		["unknown-snak-type"] = "Tipo di snak sconosciuto",
		["unknown-datavalue-type"] = "Tipo di dato sconosciuto",
		["unknown-entity-type"] = "Tipo di entità sconosciuta"
	},
	["somevalue"] = "''valore sconosciuto''",
	["novalue"] = "''nessun valore''"
}

-------------------------------------------------------------------------------
--                             Formatters
-------------------------------------------------------------------------------

local function errhandler(msg)
	local cat = mw.title.getCurrentTitle().namespace == 0 and errorCategory or ''
	return string.format('<span class="error">%s</span>%s', msg, cat)
end

local function formatExtLink(url)
	local protocols = { ftp = true, http = true, https = true }

	local success, uri = pcall(function() return mw.uri.new(url) end)
	if success and uri.protocol and protocols[uri.protocol] then
		local dest = tostring(uri)
		return string.format('[%s %s]', dest, dest:gsub(uri.protocol .. '://', ''))	
	else
		return url
	end
end

local function formatEntityId(entityId)
	local label = mw.wikibase.label(entityId)
	local link = mw.wikibase.sitelink(entityId)
	if link then
		if label and label ~= link then
			return '[[' .. link .. '|' .. label .. ']]'
		else
			return '[[' .. link .. ']]'
		end
	else
		return label or ''
	end
end

local function formatMonolingualtext(value, args)
	local ret = ''
	if not (args.langit == 'no' and value.language == 'it') then
		ret = value.text
		if args.showlang then
			ret = mLanguages.lingue( { value.language } ) .. '&nbsp;' .. ret
		end
	end
	return ret
end

local function formatTime(value, args)
	local year, month, day
	local ret = ''
 
	year, month, day = value.time:match('(%d+)%-(%d%d)%-(%d%d).+')
	if value.precision == 9 then
		ret = tonumber(year)
	elseif value.precision == 10 then
		ret = mw.getLanguage('it'):formatDate('F Y', tonumber(year) .. '-' .. month)
	elseif value.precision == 11 then
		ret = mw.getLanguage('it'):formatDate('j F Y', tonumber(year) .. '-' .. month .. '-' .. day)
		ret = ret:gsub('^1%s', '1º ')
	end
	if value.precision >= 9 and value.precision <= 11 then
		ret = ret .. (value.time:sub(1, 1) == '-' and ' a.C.' or '')
	end

	return ret
end

local function formatGlobecoordinate(value, args)
	local ret
	if args.coord == 'latitude' then
		ret = value.latitude
	elseif args.coord == 'longitude' then
		ret = value.longitude
	else
		ret = value.latitude .. ', ' .. value.longitude
	end
	return ret
end

local function formatFromPattern(str, args)
	local pattern = args.pattern
	pattern = mw.ustring.gsub(pattern, '\\{', '{')
	pattern = mw.ustring.gsub(pattern, '\\}', '}')
	return mw.getCurrentFrame():preprocess(mw.message.newRawMessage(pattern, str):plain())
end

local function getEntityIdFromValue(value)
	local prefix = ''
	if value['entity-type'] == 'item' then
		prefix = 'Q'
	elseif value['entity-type'] == 'property' then
		prefix = 'P'
	else
		error(i18n.errors['unknown-entity-type'])
	end
	return prefix .. value['numeric-id']
end

local function formatUnitSymbol(entityId, args)
	local ret = p._getProperty( { 'P558', n = 1, from = entityId } )
	if ret and args.showunitlink then
		local link = mw.wikibase.sitelink(entityId)
		if link then
			ret = string.format('[[%s|%s]]', link, ret)
		end
	end
	return ret and (' ' .. ret) or ''
end

local function formatQuantity(value, args)
	local ret = tonumber(value.amount)

	if (args.unit or args.showunit) and value.unit ~= '1' then
		local unitId = mw.ustring.match(value.unit, 'Q%d+')
		if args.unit then
			local opts = {
				showunit = args.showunit,
				showunitlink = args.showunitlink,
				formatnum = args.formatnum
			}
			ret = mConvert._main(ret, unitId, args.unit, opts)
		else
			-- se è richiesto solo il simbolo dell'unità
			-- senza la conversione lo ottiene da P558
			if args.formatnum then
				ret = mw.language.getContentLanguage():formatNum(ret)
			end
			ret = ret .. formatUnitSymbol(unitId, args)
		end
	elseif args.formatnum then
		ret = mw.language.getContentLanguage():formatNum(ret)
	end

	return ret
end

local function formatDatavalue(datavalue, snakdatatype, args)
	local ret

	if datavalue.type == 'wikibase-entityid' then
		local entityId = getEntityIdFromValue(datavalue.value)
		if args.showprop then
			ret = p._getProperty( { args.showprop, n = 1, from = entityId } )
		else
			ret = args.formatting == 'raw' and entityId or formatEntityId(entityId)
		end
	elseif datavalue.type == 'string' then
		ret = datavalue.value
		if args.extlink and snakdatatype == 'url' then
			ret = formatExtLink(ret)
		end
	elseif datavalue.type == 'monolingualtext' then
		ret = formatMonolingualtext(datavalue.value, args)
	elseif datavalue.type == 'time' then
		if args.formatting == 'raw' then
			ret = datavalue.value.time
		else
			ret = formatTime(datavalue.value, args)
		end
	elseif datavalue.type == 'globecoordinate' then
		ret = formatGlobecoordinate(datavalue.value, args)
	elseif datavalue.type == 'quantity' then
		ret = formatQuantity(datavalue.value, args)
	else
		error(i18n.errors['unknown-datavalue-type'])
	end

	return ret
end

local function formatSnak(snak, args)
	if snak.snaktype == 'somevalue' then
		return i18n['somevalue']
	elseif snak.snaktype == 'novalue' then
		return i18n['novalue']
	elseif snak.snaktype == 'value' then
		return formatDatavalue(snak.datavalue, snak.datatype, args)
	else
		error(i18n.errors['unknown-snak-type'])
	end
end

-- È al plurale perché anche i qualifier possono avere più di un valore
-- (si ottiene inserendo due volte lo stesso qualifier)
local function formatQualifiers(claim, qualifier, args, rawTable, retTable)
	local formattedQualifiers = retTable or {}

	if claim.qualifiers and claim.qualifiers[qualifier] then
		for _, q in pairs(claim.qualifiers[qualifier]) do
			local formattedQualifier = formatSnak(q, args)
			if formattedQualifier ~= '' then
				if args.pattern then
					formattedQualifier = formatFromPattern(formattedQualifier, args)
				end
				table.insert(formattedQualifiers, formattedQualifier)
			end
		end
	end

	if rawTable then
		return formattedQualifiers
	end

	return #formattedQualifiers > 0 and
		   mw.text.listToText(formattedQualifiers, args.separator, args.conjunction) or nil
end

local function appendQualifiers(statement, text, args)
	local formattedQualifiers = {}
	local qualifiers = mw.text.split(args.showqualifiers, ',')
	for _, qualifier in ipairs(qualifiers) do
		if statement.qualifiers[qualifier] then
			local formattedQualifier = formatQualifiers(statement, qualifier, args)
			table.insert(formattedQualifiers, formattedQualifier)
		end
	end
	if #formattedQualifiers > 0 then
		text = string.format('%s (%s)', text, mw.text.listToText(formattedQualifiers, ', ', ', '))
	end
	return text
end

local function formatStatement(statement, args)
	if not statement.type or statement.type ~= 'statement' then
		error(i18n.errors['unknown-claim-type'])
	end
 
	local ret = formatSnak(statement.mainsnak, args)
	-- eventuale showqualifiers
	if args.showqualifiers and statement.qualifiers then
		ret = appendQualifiers(statement, ret, args)
	end

	return ret
end

local function formatStatements(claims, args, rawTable)
	local formattedStatements = {}

	for i, claim in pairs(claims) do
		local formattedStatement = formatStatement(claim, args)
		if formattedStatement ~= '' then
			-- eventuale pattern
			if args.pattern then
				formattedStatement = formatFromPattern(formattedStatement, args)
			end
			table.insert(formattedStatements, formattedStatement)
		end
	end
	if rawTable then
		return formattedStatements
	end

	if args.list or args.orderedlist then
		table.insert(formattedStatements, 1, args.list and '<ul><li>' or '<ol><li>');
		table.insert(formattedStatements, args.list and '</li></ul>' or '</li></ol>'); 
		args.separator = '</li><li>'
		args.conjunction = args.separator
	end

	return mw.text.listToText(formattedStatements, args.separator, args.conjunction)
end

-------------------------------------------------------------------------------
--                      Lettura e selezione statement
-------------------------------------------------------------------------------

-- Ritorna true se lo statement contiene il qualifier richiesto con un dato valore
local function hasQualifierValue(statement, args)
	local ret = false
	for i, qualifier in pairs(statement.qualifiers[args.qualifier]) do
		local isItem = qualifier.snaktype == 'value' and
					   qualifier.datavalue.type == 'wikibase-entityid'
		-- per le proprietà di tipo item il confronto è eseguito sull'id
		if formatSnak(qualifier, isItem and { formatting = 'raw' } or {} ) == args.qualifiervalue then
			ret = true
			break
		end
	end
	return ret
end

-- Ritorna i claim con il rank richiesto
local function filterRankValue(claims, rank)
	local ret = {}
	for i, claim in pairs(claims) do
		if claim.rank == rank then
			table.insert(ret, claim)
		end
	end
	return ret
end

-- Ritorna una table contenente gli statement per la property richiesta,
-- oppure nil se l'entity o la proprietà non esistono.
-- Gli statement ritornati sono eventualmente filtrati in base ai parametri:
-- "rank", "qualifier", "qualifiertype" e "n"
local function getClaims(property, args)
	local entity, claims, filteredClaims
	
	-- get entity
	entity = mw.wikibase.getEntityObject(args.from)
	if not entity then
		return nil
	end

	if property and entity.claims and entity.claims[property] and
	   #entity.claims[property] > 0 then
	   claims = entity.claims[property]
	else
		return nil
	end

	-- statements filtrati per rank
	if args.rank then
		if args.rank == 'best' then
			filteredClaims = filterRankValue(claims, 'preferred')
			if #filteredClaims == 0 then
				filteredClaims = filterRankValue(claims, 'normal')
			end
		else
			filteredClaims = filterRankValue(claims, args.rank)
		end
		claims = filteredClaims
	end

	-- statements filtrati per qualifier
	if args.qualifier then
		filteredClaims = {}
		for i, claim in pairs(claims) do
			if claim.qualifiers and claim.qualifiers[args.qualifier] then
				if args.qualifiervalue then
					if hasQualifierValue(claim, args) then
						table.insert(filteredClaims, claim)
					end
				else
					table.insert(filteredClaims, claim)
				end
			end
		end
		claims = filteredClaims
	end

	-- con args.qualifiertype=latest ritorna solo il più recente
	if args.qualifier and args.qualifiertype == 'latest' then
		local latest, latestTime
		for i, claim in pairs(claims) do
			if claim.qualifiers and claim.qualifiers[args.qualifier] then
				for j, qualifier in pairs(claim.qualifiers[args.qualifier]) do
					if qualifier.datavalue.type == 'time' then
						if not latestTime or qualifier.datavalue.value.time > latestTime then
							latest = claim
							latestTime = qualifier.datavalue.value.time
						end
					end
				end
			end
		end
		claims = latest and {latest} or {}
	end

	-- con args.n ritorna solo l'n-esimo elemento
	if args.n then
		local n = tonumber(args.n)
		claims = (n and n <= #claims) and {claims[n]} or {}
	end

	return claims
end

-------------------------------------------------------------------------------
--                               API
-------------------------------------------------------------------------------

function p._getClaims(property, args)
	return getClaims(property, args or {})
end

function p._formatStatement(statement, args)
	return formatStatement(statement, args or {})
end

function p._formatQualifiers(claim, qualifier, args, rawTable, retTable)
	return formatQualifiers(claim, qualifier, args or {}, rawTable, retTable)
end

-- Ritorna il valore di una proprietà di Wikidata oppure nil se l'entity o
-- la proprietà non esistono, o se per parametri di selezione gli statement sono zero.
function p._getProperty(args, rawTable)
	local property, value, claims

	-- parametri posizionali
	property = args[1] and string.upper(args[1]) or nil
	if not property then
		error(i18n.errors['property-param-not-provided'], 2)
	end
	value = args[2]
	-- fix uppercase
	args.qualifier = args.qualifier and string.upper(args.qualifier) or nil
	
	-- if parameter value is already set, use it
	if value then
		if args.extlink then
			value = formatExtLink(value)
		end
		return args.pattern and formatFromPattern(value, args) or value 
	end
	
	-- default rank
	args.rank = args.rank or 'best'

	-- get claims
	claims = getClaims(property, args)

	return (claims and #claims > 0) and formatStatements(claims, args, rawTable) or nil
end

-- Ritorna il valore di un qualifier di una proprietà di Wikidata,
-- o nil se l'entity o la proprietà non esistono, o se per parametri di selezione non ci sono risultati.
function p._getQualifier(args)
	local property, qualifier, value, claims
	
	-- parametri posizionali
	property = args[1] and string.upper(args[1]) or nil
	if not property then
		error(i18n.errors['property-param-not-provided'], 2)
	end
	qualifier = args[2] and string.upper(args[2]) or nil
	if not qualifier then
		error(i18n.errors['qualifier-param-not-provided'], 2)
	end
	value = args[3]
	
	-- if parameter value is already set, use it
	if value then
		return args.pattern and formatFromPattern(value, args) or value 
	end

	-- default rank
	args.rank = args.rank or 'best'

	-- get claims
	claims = getClaims(property, args)
	if not claims or #claims == 0 then
		return nil
	end

	local formattedQualifiers = {}
	for _, claim in pairs(claims) do
		formattedQualifiers = formatQualifiers(claim, qualifier, args, true, formattedQualifiers)
	end

	return #formattedQualifiers > 0 and
		   mw.text.listToText(formattedQualifiers, args.separator, args.conjunction) or nil
end

-- Ritorna l'indice dello statement con il valore richiesto, o -1 se non trovato.
function p._indexOf(args)
	local ret, property, value, claims

	-- parametri posizionali
	property = args[1] and string.upper(args[1]) or nil
	if not property then
		error(i18n.errors['property-param-not-provided'], 2)
	end
	value = args[2]
	if not value then
		error(i18n.errors['value-param-not-provided'], 2)
	end

	-- default rank
	args.rank = args.rank or 'best'

	-- get claims
	claims = getClaims(property, args)
	if not claims or #claims == 0 then
		return -1
	end

	args.formatting = 'raw'
	for i, claim in pairs(claims) do
		if formatStatement(claim, args) == value then
			ret = i
			break
		end
	end

	return ret or -1
end

-- Ritorna il numero di statement di una proprietà di Wikidata.
function p._N(args) 
	local entity, property, count

	-- parametri posizionali
	property = args[1] and string.upper(args[1]) or nil
	if not property then
		error(i18n.errors['property-param-not-provided'], 2)
	end

	entity = mw.wikibase.getEntityObject(args.from)
	if entity and entity.claims and entity.claims[property] then
		count = #entity.claims[property]
	end

	return count or 0
end

-- Ritorna true se la proprietà P31 (instance of) ha come valore almeno uno tra gli entityId specificati
function p._instanceOf(args)
	local statements = p._getProperty( { 'P31', from = args.from, formatting = 'raw' }, true)
	if statements then
		for _, statement in ipairs(statements) do
			for _, entityId in ipairs(args) do
				if statement == entityId then
					return true
				end
			end
		end
	end

	return false
end

-- Ritorna l'etichetta di un item o di una proprietà Wikidata.
function p._getLabel(args) 
	-- parametri posizionali
	local entityId = args[1] and string.upper(args[1]) or nil
	if not entityId then
		error(i18n.errors['entityid-param-not-provided'], 2)
	end

	return mw.wikibase.label(entityId)
end

-- Ritorna il titolo della pagina collegata a un dato item Wikidata.
function p._getLink(args) 
	-- parametri posizionali
	local entityId = args[1] and string.upper(args[1]) or nil
	if not entityId then
		error(i18n.errors['entityid-param-not-provided'], 2)
	end
	
	return entityId:sub(1, 1) == 'Q' and formatEntityId(entityId) or nil
end

-- Ritorna il datatype di una proprietà Wikidata.
function p._getDatatype(args) 
	local ret, property, entity, datatype

	-- parametri posizionali
	property = args[1] and string.upper(args[1]) or nil
	if not property then
		error(i18n.errors['property-param-not-provided'], 2)
	end

	entity = mw.wikibase.getEntityObject(property)
	if not entity then
		error(i18n.errors['entity-not-found'], 2)
	end

	datatype = entity.datatype
	if datatype == 'commonsMedia' then
		ret = 'file multimediale su Commons'
	elseif datatype == 'globe-coordinate' then
		ret = 'coordinate geografiche'
	elseif datatype == 'monolingualtext' then
		ret = 'testo monolingua'
	elseif datatype == 'quantity' then
		ret = 'quantità'
	elseif datatype == 'string' then
		ret = 'stringa'
	elseif datatype == 'time' then
		ret = 'data e ora'
	elseif datatype == 'url' then
		ret = 'URL'
	elseif datatype == 'external-id' then
		ret = 'identificatore esterno'
	elseif datatype == 'wikibase-item' then
		ret = 'elemento'
	elseif datatype == 'wikibase-property' then
		ret = 'proprietà'
	elseif datatype == 'math' then
		ret = 'espressione matematica'
	else
		error(i18n.errors['unknown-datavalue-type'], 2)
	end

	return ret
end

-- Ritorna l'ID dell'item Wikidata collegato alla pagina corrente.
function p._getId() 
	local entity = mw.wikibase.getEntityObject()
	return entity and entity.id or nil
end

-- Entry-point per {{Wikidata}}
function p.getProperty(frame)
	return select(2, xpcall(function()
		return p._getProperty(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataQ}}
function p.getQualifier(frame)
	return select(2, xpcall(function()
		return p._getQualifier(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataIdx}}
function p.indexOf(frame)
	return select(2, xpcall(function()
		return p._indexOf(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataN}}
function p.N(frame)
	return select(2, xpcall(function()
		return p._N(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataLabel}}
function p.getLabel(frame)
	return select(2, xpcall(function()
		return p._getLabel(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataLink}}
function p.getLink(frame)
	return select(2, xpcall(function()
		return p._getLink(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataIstanza}}
function p.instanceOf(frame)
	return select(2, xpcall(function()
		return p._instanceOf(getArgs(frame, {parentOnly = true})) and 1 or 0
	end, errhandler))
end

-- Entry-point per {{WikidataTipo}}
function p.getDatatype(frame)
	return select(2, xpcall(function()
		return p._getDatatype(getArgs(frame, {parentOnly = true}))
	end, errhandler))
end

-- Entry-point per {{WikidataId}}
function p.getId(frame)
	return select(2, xpcall(function()
		return p._getId()
	end, errhandler))
end

return p