Mostrar código-fonte de Módulo:WikidataIB

-- Módulo para experimentar o uso de uma lista de campos proibidos e uma lista de campos permitidos
-- Pode pegar um parâmetro nomeado |qid que é o identificador da página no Wikidata. Em geral, seu uso deve ser restrito a páginas de teste e documentações.
-- Os campos colocados na lista de proibições não serão exibidos de forma alguma, ou seja, o módulo deverá retornar nul para esses campos
-- Os campos colocados na lista de permissões terão valores devolvidos sempre que existirem localmente
-- O nome do campo em que esta função é chamada é passado através do parâmetro nomeado |nome
-- O nome é obrigatório somente quando a lista de proibições e/ou a lista de permissões são usadas. O módulo retornará nul caso ele não seja passado
-- A lista de proibições é passada através do parâmetro nomeado |supressfields
-- A lista de permissões é passada através do parâmetro nomeado |fetchwikidata

local p = {}

local wiki =
{
    langcode = mw.language.getContentLanguage().code
}

local i18n =
{
    ["errors"] =
    {
        ["property-not-found"] = "Propriedade não encontrada.",
        ["entity-not-found"] = "Entidade Wikidata desconhecida.",
        ["unknown-claim-type"] = "Tipo claim com valor desconhecido.",
        ["unknown-entity-type"] = "Tipo entity com valor desconhecido.",
        ["qualifier-not-found"] = "Qualificador não encontrado.",
        ["site-not-found"] = "Projeto Wikimedia não encontrado.",
        ["unknown-datetime-format"] = "Formato datatempo desconhecido.",
        ["local-article-not-found"] = "Notícia ainda não se encontra disponível nesta wiki."
    },
    ["editenowikidata"] = "Edite no Wikidata",
    ["filespace"] = "Ficheiro",
    ["months"] =
    {
    	"janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"
    },
    ["ac"] = "a.C.",
    ["century"] = "[[Século $1]]",
    ["centurysemlink"] = "século $1",
    ["decade"] = "[[Década de $1]]",
    ["decadesemlink"] = "década de $1"
}


-------------------------------------------------------------------------------
-- Private functions
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
-- formatDate pega uma data no formato usual de mw.wikibase.entity:formatPropertyValues
-- como "1 de agosto de 30 aC" como primeiro parâmetro e o formata de acordo com os parâmetros dateformat (formato de data), bc (indicador de era), idioma e datasemlink
-- df = <"dmy"/"mdy"/"y">. O valor padrão é "dmy"
-- bc = <"a.C.">. O valor padrão será "a.C."
-- idioma = <"pt"/"pt-ao"/"">. O valor padrão é "", e significa que a data será exibida no formato português brasileiro. "pt" representa o formato português europeu e "pt-ao" o formato do português angolano.
-- datasemlink = <"sim"/"">. O valor padrão é "", e significa que a data será devolvida em formato wiki.
-- primeiro a versão local
local format_Date = function(frame,datetime, dateformat, bc, idioma, datasemlink)
	local datetime = datetime or "14 de fevereiro 1 August 30 BCE" -- in case of nil value
	-- chop off multiple vales and/or any hours, mins, etc.
	-- keep anything before punctuation - we just want a single date:
	local dateval = string.match( datetime, "[%w ç]+")
	local dateformat = string.lower(dateformat or "dmy") -- default to dmy
	local datasemlink = datasemlink
	
	local c1
	local c2
	if datasemlink == "sim" then
		c1 = ""
		c2 = ""
	else
		c1 = "[["
		c2 = "]]"
	end
	
	local bc = string.upper(bc or "") -- can't use nil for bc
	-- we only want to accept two possibilities: BC or default to BCE
	if bc=="BCE" then
		bc = " " .. i18n["ac"] -- prepend the space. **internationalise later**
	else
		bc = " " .. i18n["ac"]
	end
	local postchrist = true -- start by assuming no BCE
	local dateparts = {}
	for word in string.gmatch(dateval,"([%w-ç]+)") do
		if word == "BC" or word=="BCE" then -- **internationalise later**
			postchrist = false
		else
			-- we'll keep the parts that are not 'BCE' in a table
			dateparts[#dateparts + 1] =  word
		end
	end
	if postchrist then bc = "" end -- set AD dates to no suffstring.("$1","$1",**internationalise later**
	local sep = " de " -- separator is nbsp
	local fdate = table.concat(dateparts, " de ") -- formatted date defaults to same order as input
	-- if we have day month year, check dateformat
	if #dateparts == 3 then
		--por padrão dmy
		--se é dia primeiro
		if idioma == "pt" then
			fdate = c1..dateparts[1]..sep..dateparts[2]..c2..sep..c1..dateparts[3]..bc..c2
		elseif idioma =="pt-ao" then
			fdate = c1..dateparts[1]..sep..dateparts[2]:gsub("^%l", string.upper)..c2..sep..c1..dateparts[3]..bc..c2
		else
			if dateparts[1]==tostring(1) then
				fdate = c1..dateparts[1].."º"..sep..dateparts[2]..c2..sep..c1..dateparts[3]..bc..c2
			else
				fdate = c1..dateparts[1]..sep..dateparts[2]..c2..sep..c1..dateparts[3]..bc..c2
			end
		end
		if dateformat == "y" then
			fdate = c1..dateparts[3]..bc..c2
		elseif dateformat == "my" then
			if idioma =="pt-ao" then
				fdate = c1..dateparts[2]:gsub("^%l", string.upper) ..c2.. sep .. c1 .. dateparts[3] ..bc.. c2
			else
				fdate = c1..dateparts[2]:gsub("^%l", string.upper) ..c2.. sep .. c1 .. dateparts[3] ..bc.. c2
			end
		end
	elseif #dateparts == 2 then
		if dateformat == "y" then
			fdate = c1..dateparts[2]..bc..c2
		else
			if idioma == "pt-ao" then
				fdate = c1..dateparts[1]:gsub("^%l", string.upper)..c2..sep..c1..dateparts[2]..bc..c2
			else
				fdate = c1..dateparts[1]..c2..sep..c1..dateparts[2]..bc..c2
			end
		end
	else
		fdate = c1..dateparts[1]..bc..c2
	end
	
	return fdate
end

local format_Date_template = function(frame,datetime, dateformat, bc, idioma)
	local datetime = datetime or "14 de fevereiro"
	local dateval = string.match( datetime, "[%w ç]+")
	local dateformat = string.lower(dateformat or "dmy")
	
	local bc = string.upper(bc or "")
	bc = "-"
	
	local function _numes(mes)
		local result = mes
		for k, v in ipairs(i18n["months"]) do
			if mes == v then
				result = tostring(k)
			end
		end
		return result
	end
	
	local postchrist = true -- start by assuming no BCE
	local dateparts = {}
	for word in string.gmatch(dateval,"([%w-ç]+)") do
		if word == "BC" or word=="BCE" then -- **internationalise later**
			postchrist = false
		else
			-- we'll keep the parts that are not 'BCE' in a table
			dateparts[#dateparts + 1] =  _numes(word)
		end
	end
	if postchrist then bc = " " end
	local sep = "|"
	local fdate = table.concat(dateparts, sep)
	if #dateparts == 3 then
		if dateformat == "y" then
			fdate = sep..sep..mw.text.trim(bc)..dateparts[3]
		elseif dateformat == "my" then
			fdate = sep..dateparts[2]..sep..mw.text.trim(bc)..dateparts[3]
		else
			fdate = dateparts[1]..sep..dateparts[2]..sep..mw.text.trim(bc)..dateparts[3]
		end
	elseif #dateparts == 2 then
		if dateformat == "y" then
			fdate = sep..sep..mw.text.trim(bc)..dateparts[2]
		else
			fdate = sep..dateparts[1]..sep..mw.text.trim(bc)..dateparts[2]
		end
	else
		fdate = sep..sep..mw.text.trim(bc)..dateparts[1]
	end
	
	return fdate
end


-------------------------------------------------------------------------------
-- parseParam takes a (string) parameter, e.g. from the list of frame arguments,
-- and makes "false", "no", and "0" into the (boolean) false
-- it makes the empty string and nil into the (boolean) value passed as default
-- allowing the parameter to be true or false by default.
local parseParam = function(param, default)
	if param and (#param > 0) then
		param = param:lower()
		if (param == "false") or (param == "no") or (param == "não") or (param == "0") then
			return false
		else
			return true
		end
	else
		return default
	end
end

-------------------------------------------------------------------------------
-- The label in a Wikidata item is subject to vulnerabilities 
-- that an attacker might try to exploit.
-- It needs to be 'sanitised' by removing any wikitext before use.
-- If it doesn't exist, just return the id for the item
local labelOrId = function (id,idioma)
	local label = ""
	if idioma == "pt" or idioma == "pt-ao" then
		label = mw.wikibase.getLabelByLang(id,'pt') or mw.wikibase.getLabelByLang(id,'pt-br') or ""
	else
		label = mw.wikibase.getLabelByLang(id,'pt-br') or mw.wikibase.getLabelByLang(id,'pt') or ""
	end
	if label ~= "" then
		return mw.text.nowiki(label)
	else
		return id
	end
end

-------------------------------------------------------------------------------
-- sourced takes a table representing a statement that may or may not have references
-- it counts how many references are sourced to something not contianing the word "wikipedia"
-- the reference string "ref" is available for debugging
-- it returns a boolean = true if there are any sourced references.
local sourced = function(claim)
	local refs = 0
	if claim.references then
		for kr, vr in pairs(claim.references) do
			local ref = mw.wikibase.renderSnaks(vr.snaks)
			if not ref:find("Wikipedia") then refs = refs + 1 end
		end
	end
	return refs > 0
end

-------------------------------------------------------------------------------
-- parseInput processes the Q-id , the blacklist and the whitelist
-- if an input parameter is supplied, it returns that and ends the call.
-- it returns a boolean indicating whether or not the call should continue
-- and an object containing all of the Wikidata for the Qid supplied or the current page
local parseInput = function(frame, input_parm, property_id)
	-- can take a named parameter |qid which is the Wikidata ID for the article.
	-- This will not normally be used because it's an expensive call.
	local qid = frame.args.qid
	if qid and (#qid == 0) then qid = nil end
	
	-- The blacklist is passed in named parameter |suppressfields
	local blacklist = frame.args.suppressfields
	
	-- The whitelist is passed in named parameter |fetchwikidata
	local whitelist = frame.args.fetchwikidata
	
	-- The name of the field that this function is called from is passed in named parameter |name
	local fieldname = frame.args.name
	if blacklist then
		-- The name is compulsory when blacklist is used, so return nil if it is not supplied
		if not fieldname or (#fieldname == 0) then return false, nil, nil end
		-- If this field is on the blacklist, then return nil
		if blacklist:find(fieldname) then return false, nil, nil end
	end
	
	-- If we got this far then we're not on the blacklist
	-- The blacklist overrides any locally supplied parameter as well
	-- If a non-blank input parameter was supplied return it
	if input_parm then return false, input_parm, nil end
	
	-- Otherwise see if this field is on the whitelist:
	if not (whitelist and (whitelist == 'ALL' or whitelist:find(fieldname))) then
		-- not on the whitelist so just return what should be a nil input parameter
		return false, input_parm, nil
	end
	
	-- See what's on Wikidata:
	local entity = mw.wikibase.getEntityObject(qid)
	if entity and entity.claims then
		local props = entity.claims[property_id]
		if props and props[1] then 
			return true, entity, props
		end
	end
	-- no property on Wikidata
	return false, input_parm, nil
end

-------------------------------------------------------------------------------
local function _getvalue(frame, entity, props, filter, propertyID, unit) 
	-- onlysourced is a boolean passed to return only values sourced to other than Wikipedia
	-- if nothing or an empty string is passed set it true
	-- if "false" or "no" or "0" is passed set it false
	local onlysrc = parseParam(frame.args.onlysourced, true)
	
	-- noicon is a boolean passed to suppress the trailing "edit at Wikidata" icon
	-- for use when the value is processed further by the infobox
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or "0" is passed set it false
	local noic = parseParam(frame.args.noicon, false)
	
	-- wdlinks is a boolean passed to enable links to Wikidata when no article exists
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or "0" is passed set it false
	local wdl = parseParam(frame.args.wdlinks, false)
	
	-- sorted is a boolean passed to enable sorting of the values returned
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or "0" is passed set it false
	local sorted = parseParam(frame.args.sorted, false)
	
	-- separator is a string that is used to separate multiple returned values
	-- if nothing or an empty string is passed set it to the default
	-- any double-quotes " are stripped out, so that spaces may be passed
	-- e.g. |sep=" - "
	local sepdefault = ", " -- **internationalise later**
	local separator = frame.args.sep or ""
	if separator=="nenhum" then
		separator = ""
	else
		separator = string.gsub(separator, '"', '')
		if #separator == 0 then
			separator = sepdefault
			end
	end
	
	-- list is a string that may be "", "hlist" or "ubl"
	-- this controls whether multiple values are output as comma-separated
	-- as a horizontal list (hlist) or unbulleted list (ubl)
	local list = frame.args.list or ""
	if list~="hlist" and list~="ubl" then list = "" end
	
	-- prefix is a string that may be nil, empty (""), or a string of characters
	-- this is prefixed to each value
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local prefix = frame.args.prefix or ""
	prefix = string.gsub(prefix, '"', '')
	
	-- postfix is a string that may be nil, empty (""), or a string of characters
	-- this is postfixed to each value
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local postfix = frame.args.postfix or ""
	postfix = string.gsub(postfix, '"', '')
	
	-- linkprefix is a string that may be nil, empty (""), or a string of characters
	-- this creates a link and is then prefixed to each value
	-- useful when when multiple values are returned and indirect links are needed
	-- any double-quotes " are stripped out, so that spaces may be passed
	local lprefix = frame.args.linkprefix or ""
	lprefix = string.gsub(lprefix, '"', '')
	
	-- linkpostfix is a string that may be nil, empty (""), or a string of characters
	-- this is postfixed to each value when linking is enabled with lprefix
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local lpostfix = frame.args.linkpostfix or ""
	lpostfix = string.gsub(lpostfix, '"', '')
	
	-- maxvals is a string that may be nil, empty (""), or a number
	-- this determines how many items may be returned when multiple values are available
	-- the behaviour is customisable for each different data type
	local maxvals = tonumber(frame.args.maxvals) or -1
	
	-- contagem is a string that may be empty (""), or "sim"
	-- for use when one wants to get the quantity of values returned
	local contagem = frame.args.contagem or ""
	
	-- So now we have something to return: deal with:
	-- (1) ["datatype"] = "wikibase-item";
	-- (2) ["datatype"] = "time";
	-- (3) ["datatype"] = "commonsMedia",
	--     ["datatype"] = "external-id",
	--     ["datatype"] = "string",
	--     ["datatype"] = "url"
	-- (4) ["datatype"] = "quantity"
	-- (5) ["datatype"] = "globe-coordinate", or anything else
	
	
	local lang = mw.language.getContentLanguage().code
	local thisQid = entity.id
	-- table 'out' is going to to store the return value(s):
	local out = {}
	local semlink = frame.args.semlink or "não"
	local semlink = frame.args.artigosemlink or "não"
	local icon = " [[" .. i18n["filespace"] .. ":Blue pencil.svg |frameless |text-top |10px |alt=" .. i18n["editenowikidata"] .. "|link=https://www.wikidata.org/wiki/" .. thisQid .. "?uselang=" .. lang .. "#" .. propertyID .. "|" .. i18n["editenowikidata"] .. "]]"
	local dni = frame.args.dni or "não"
	
	-- data type is a wikibase item:
	if props[1].mainsnak.datatype == "wikibase-item" then
		-- it's wiki-linked value, so output as link if possible
		for k, v in pairs(props) do
			if filter(v) and ((onlysrc == false) or sourced(v)) then -- has valid refs or all values required
				if v.mainsnak.snaktype == "somevalue" then -- check for value is unknown
					out[#out + 1] = "Desconhecido"
				elseif v.mainsnak.snaktype == "novalue" then -- check for value is none
					-- out[#out + 1] = "No value" -- don't return a value for this
				else
					local qnumber = "Q" .. v.mainsnak.datavalue.value["numeric-id"]
					local sitelink = mw.wikibase.sitelink(qnumber)
					local label = labelOrId(qnumber,frame.args.idioma or "pt-br")
					
					local gender = frame.args.gender or ""
					if gender ~= "" and entity.claims["P21"] then
						local genderID = entity.claims["P21"][1].mainsnak.datavalue.value["id"]
						if genderID == "F" or genderID == "Q6581072" or genderID == "Q1052281" or genderID == "Q43445" then
							local genderEntity = mw.wikibase.getEntityObject(qnumber)
							if genderEntity.claims["P2521"] then
								for k2,v2 in pairs(genderEntity.claims["P2521"]) do
									if filter(v2) and (v2.mainsnak.datavalue.value["language"] == "pt-br" or v2.mainsnak.datavalue.value["language"] == "pt") then
										label = v2.mainsnak.datavalue.value["text"]
									end
								end
							end
						end
					end
					
					if label ~= qnumber then
						if sitelink then
							if semlink == "sim" then
								out[#out + 1] = label
							else
								if sitelink ~= label then
									if artigosemlink == "sim" then
										out[#out + 1] = sitelink
									else
										out[#out + 1] = "[[" .. sitelink .. "|" .. label .. "]]" -- devolve o link pro artigo com um rótulo label
									end
								else
									if artigosemlink == "sim" then
										out[#out + 1] = sitelink
									else
										out[#out + 1] = "[[" .. sitelink .. "]]" -- devolve o link pro artigo com um rótulo sitelink
									end
								end
							end
						else
							-- no sitelink, so check first for a redirect with that label
							local artitle = mw.title.new(label, 0)
							if artitle.id > 0 then
								if artitle.isRedirect then
									-- no sitelink, but there's a redirect with the same title as the label
									-- let's link to that
									out[#out + 1] = label -- Devolve só o label, pois ter um redirecionamento com o mesmo rótulo não implica que os itens estão ligados.
								else
									-- no sitelink and not a redirect but an article exists with the same title as the label
									-- that's probably a dab page, so output the plain label
									out[#out + 1] = label -- Devolve só o label, pois título do artigo igual ao label não implica que os itens estão ligados.
								end
							else
								-- no article or redirect with the same title as the label
								if wdl then
									-- show that there's a Wikidata entry available
									out[#out + 1] = "[[:d:Q" .. v.mainsnak.datavalue.value["numeric-id"] .. "|" .. label .. "]] <span title='" .. i18n["errors"]["local-article-not-found"] .. "'>[[File:Wikidata-logo.svg|16px|alt=|link=]]</span>"
								else
									-- no wikidata links required, so don't show it
									out[#out + 1] = label
								end
							end
						end
					end
					-- If the property has a qualifier of latest date, add that in all cases:
					if v.qualifiers then
						local quals = v.qualifiers["P1326"] -- latest date qualifier
						if quals and #out>0 then
							out[#out] = out[#out] .. " (" ..mw.wikibase.renderSnaks(quals) .. ")"
						end
					end
				end -- check for unknown value
			end -- check for sourced
			if maxvals > 0 and #out >= maxvals then break end
		end -- loop through k-v pairs
	
	-- data type is time:
	elseif props[1].mainsnak.datatype == "time" then
		local datamorte = ""
		-- it's a date value, so output according to formatting preferences
		for k, v in pairs(props) do
			-- check for references, and count valid references
			if filter(v) and ((onlysrc == false) or sourced(v)) then
				if v.mainsnak.snaktype == "somevalue" then -- check for value is unknown
					out[#out + 1] = "Desconhecido"
				elseif v.mainsnak.snaktype == "novalue" then -- check for value is none
					-- out[#out + 1] = "No value" -- don't return a value for this
				else
					local timestamp = v.mainsnak.datavalue.value.time
					-- A year can be stored like this: "+1872-00-00T00:00:00Z",
					-- which is processed here as if it were the day before "+1872-01-01T00:00:00Z",
					-- and that's the last day of 1871, so the year is wrong.
					-- So fix the month 0, day 0 timestamp to become 1 January instead:
					timestamp = timestamp:gsub("%-00%-00T", "-01-01T")
					local dateprecision = v.mainsnak.datavalue.value.precision
					local fpvdate = tonumber(timestamp:sub(2, 5))
					local fdate
					if dateprecision >= 9 then -- 9 is year precision
						local dateformat = "y"
						if dateprecision >= 10 then -- prepend month
							if dni ~= "não" then
								fpvdate = tonumber(timestamp:sub(7, 8)) .. " " .. fpvdate
							else
								fpvdate = i18n.months[tonumber(timestamp:sub(7, 8))] .. " " .. fpvdate
							end
							dateformat = frame.args.df
							if dateprecision >= 11 then -- prepend day
									fpvdate = tonumber(timestamp:sub(10, 11)) .. " " .. fpvdate
							end
							if timestamp:sub(1, 1) == "-" then
								fpvdate = fpvdate .. " BCE"
							end
						else
							if timestamp:sub(1, 1) == "-" then
								fpvdate = fpvdate.." BCE"
							end
						end
						local idioma = frame.args.idioma or "pt-br"
						local datasemlink = frame.args.datasemlink or semlink
						if dni ~= "não" then
							if entity.claims["P570"] then
								datamorte = "existe"
							end
						end
						if frame.args.display=="predefinição" then
							fdate  = format_Date_template(frame,fpvdate,dateformat,frame.args.bc,frame.args.idioma)
						else
							fdate  = format_Date(frame,fpvdate, dateformat, frame.args.bc,frame.args.idioma,frame.args.datasemlink,datamorte,dni)
						end
					elseif dateprecision == 8 then -- decade
						local datasemlink = frame.args.datasemlink or semlink
						local decade = fpvdate or ""
						if timestamp:sub(1, 1) == "-" then -- date is BC
							if datasemlink == "sim" then
								fdate = mw.ustring.gsub(i18n["decadesemlink"], "$1", decade.." "..i18n["ac"])
							else
								fdate = mw.ustring.gsub(i18n["decade"], "$1", decade.." "..i18n["ac"])
							end
						else
							if datasemlink == "sim" then
								fdate = mw.ustring.gsub(i18n["decadesemlink"], "$1", decade)
							else
								fdate = mw.ustring.gsub(i18n["decade"], "$1", decade)
							end
						end
						if frame.args.display=="predefinição" then
							fdate = decade
						end
					elseif dateprecision == 7 then -- century
						local datasemlink = frame.args.datasemlink or semlink
						local century = require("Módulo:Romano")._main({math.floor((fpvdate - 1) / 100) + 1})
						if timestamp:sub(1, 1) == "-" then -- date is BC
							if datasemlink == "sim" then
								fdate = mw.ustring.gsub(i18n["centurysemlink"], "$1", century.." "..i18n["ac"])
							else
								fdate = mw.ustring.gsub(i18n["century"], "$1", century.." "..i18n["ac"])
							end
						else
							if datasemlink == "sim" then
								fdate = mw.ustring.gsub(i18n["centurysemlink"], "$1", century)
							else
								fdate = mw.ustring.gsub(i18n["century"], "$1", century)
							end
						end
					else
						-- date precisions 0 to 6 (billion years to millenium) TODO:
						--
					end
					out[#out+1] = fdate
				end -- check for unknown value
			end -- check for sourced
			if maxvals > 0 and #out >= maxvals then break end
		end -- loop through k-v pairs
	
	-- data types which are strings:
	elseif props[1].mainsnak.datatype == "commonsMedia" or props[1].mainsnak.datatype == "external-id" or props[1].mainsnak.datatype == "string" or props[1].mainsnak.datatype == "url" then
		-- commonsMedia or external-id or string or url
		-- all have mainsnak.datavalue.value as string
		for k, v in pairs(props) do
			if filter(v) and ((onlysrc == false) or sourced(v)) then -- has valid refs or all values required
				if v.mainsnak.snaktype == "somevalue" then -- check for value is unknown
					out[#out + 1] = "Desconhecido"
				elseif v.mainsnak.snaktype == "novalue" then -- check for value is none
					-- out[#out + 1] = "No value" -- don't return a value for this
				else
					if lprefix > "" then
						out[#out+1] = "[[" .. lprefix .. v.mainsnak.datavalue.value .. lpostfix .. "|" .. prefix .. v.mainsnak.datavalue.value .. postfix .. "]]"
					else
						if postfix == "ref" then
							out[#out+1] = "<ref name =" .. string.match(v.mainsnak.datavalue.value, "%.(.-)%.") .. "-" .. string.match(v.mainsnak.datavalue.value, "^.+/(.-)$") .. ">" .. v.mainsnak.datavalue.value .. "</ref>"
						else
							out[#out+1] = prefix .. v.mainsnak.datavalue.value .. postfix
						end
					end -- check for link requested
				end -- check for unknown value
			end -- check for sourced
			if maxvals > 0 and #out >= maxvals then break end
		end -- loop through k-v pairspairs
	
	-- data types which are quantities:
	elseif props[1].mainsnak.datatype == "quantity" then
		for k, v in pairs(props) do
			if filter(v) and ((onlysrc == false) or sourced(v)) then -- has valid refs or all values required
				if v.mainsnak.snaktype == "somevalue" then -- check for value is unknown
					out[#out + 1] = "Desconhecido"
				elseif v.mainsnak.snaktype == "novalue" then -- check for value is none
					-- out[#out + 1] = "No value" -- don't return a value for this
				else
					local amount = v.mainsnak.datavalue.value.amount
					amount = mw.ustring.gsub(amount, "%+", "")
					local sortkey = string.format("%09d", amount)
					local lang = mw.language.new(wiki.langcode)
					amount = lang:formatNum(tonumber(amount))
					-- This is used to get the unit name for a numeric value
					local suffix = ""
					local unitID = v.mainsnak.datavalue.value.unit
					unitID = mw.ustring.sub(unitID, mw.ustring.find(unitID, "Q"), -1)
					if mw.ustring.sub(unitID, 1, 1) == "Q" then
						local unit_label = mw.wikibase.label(unitID)
						suffix = " " .. require("Módulo:Wikidata/Unidades").getUnit(amount, unit_label, unitID, unit == "unidade")
					end
					out[#out+1] = amount .. suffix .. postfix
				end
			end	
			if maxvals > 0 and #out >= maxvals then break end
		end
	
	-- data types which are monolingualtext:
	elseif props[1].mainsnak.datatype == "monolingualtext" then
		for k, v in pairs(props) do
			if filter(v) and ((onlysrc == false) or sourced(v)) then -- has valid refs or all values required
				if v.mainsnak.datavalue.value.language == 'pt-br' or v.mainsnak.datavalue.value.language == 'pt' then
					out[#out+1] = v.mainsnak.datavalue.value.text
				end -- check for language values
			end -- check for sourced
			if maxvals > 0 and #out >= maxvals then break end
		end
	-- some other data type:
	else
		-- some other data type
		-- e.g. globe-coordinate where mainsnak.datavalue.value is a table
		-- either write a specific handler
		-- or we can use formatPropertyValues() as a temporary measure. This won't work with multiple valid values.
		for k, v in pairs(props) do
			if filter(v) and ((onlysrc == false) or sourced(v)) then -- has valid refs or all values required
				local propertyValue = entity:formatPropertyValues(propertyID).value
				out[#out+1] = propertyValue
				break
			end -- check for sourced
			if maxvals > 0 and #out >= maxvals then break end
		end
	end
	
	-- if there's anything to return, then return a list
	-- comma-separated by default, but may be specified by the sep parameter
	-- optionally specify a hlist or ubl
	
	if #out > 0 then
		if sorted then table.sort(out) end
		if list == "hlist" then
			return frame:expandTemplate{title = 'Hlist', args = out}
		elseif list == "ubl" then
			return frame:expandTemplate{title = 'Unbulleted list', args = out}
		else
			if noic then
				if contagem == "sim" then
					return #out
				else
					return table.concat(out, separator)
				end
			else
				if contagem == "sim" then
					return #out
				else
					return table.concat(out, separator) .. icon
				end
			end
		end
	else
		return nil -- no items had valid reference
	end
end

-------------------------------------------------------------------------------
-- Public functions
-------------------------------------------------------------------------------
-- getValue is used to get a value, or a comma separated list of them if multiple values exist
--

p.getValue = function(frame)
	local propertyID = mw.text.trim(frame.args[1] or "")
	
	-- There may be a local parameter supplied, if it's blank, set it to nil
	local input_parm =  mw.text.trim(frame.args[2] or "")
	local unit = mw.text.trim(frame.args[3] or "")
	if input_parm and (#input_parm == 0) then input_parm = nil end
	local success, errorOrEntity, props = parseInput(frame, input_parm, propertyID)
	if not success then
		return errorOrEntity
	else
		entity = errorOrEntity
	end
	local function filter(claim)
		return true
	end
	return _getvalue(frame, entity, props, filter, propertyID, unit)
end
-------------------------------------------------------------------------------
-- getPreferredValue is used to get a value, or a comma separated list of them if multiple values exist
-- If preferred ranks are set, it will return those values, otherwise values with normal ranks
--
p.getPreferredValue = function(frame)
	local propertyID = mw.text.trim(frame.args[1] or "")
	
	-- There may be a local parameter supplied, if it's blank, set it to nil
	local input_parm =  mw.text.trim(frame.args[2] or "")
	local unit =  mw.text.trim(frame.args[3] or "")
	if input_parm and (#input_parm == 0) then input_parm = nil end
	local success, errorOrEntity, props = parseInput(frame, input_parm, propertyID)
	if not success then
		return errorOrEntity
	else
		entity = errorOrEntity
	end
	local prefflag = false
	for k, v in pairs(props) do
		if v.rank == "preferred" then 
			prefflag = true 
			break
		end
	end
	local function filter(claim)
		return claim.rank == "preferred" or prefflag == false
	end
	return _getvalue(frame, entity, props, filter, propertyID, unit)
end

-------------------------------------------------------------------------------
-- getSourcedValue is used to get a value, or a comma separated list of them if multiple values exist
-- but only values that are sourced are returned
-- redundant to getValue with onlysourced=true but kept for backwards compatibility
-- now defined via getValue
--
p.getSourcedValue = function(frame)
	frame.args.onlysourced = "yes"
	return p.getValue(frame)
end


-------------------------------------------------------------------------------
-- getCoords is used to get coordinates for display in an infobox
-- whitelist and blacklist are implemented
-- optional 'display' parameter is allowed, defaults to "inline, title"
--
p.getCoords = function(frame)
	local propertyID = "P625"
	local input_parm =  mw.text.trim(frame.args[1] or "")
	if input_parm and (#input_parm == 0) then input_parm = nil end
	
	-- if there is a 'display' parameter supplied, use it
	-- otherwise default to "inline, title"
	local disp = frame.args.display
	if (not disp) or (#disp == 0) then
		disp = "inline, title"
	end
	
	local success, errorOrEntity = parseInput(frame, input_parm, property_id)
	if not success then
		return errorOrEntity
	else
		local entity = errorOrEntity
		local lat_long = {}
		local coords = entity:formatPropertyValues(propertyID).value
		-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
		-- using html entities with hex values really screws up parsing the numbers - thanks devs
		local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from the start to before the comma
		local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after the space to the end
		lat = lat:gsub("&#%d%d;", ":")                  -- clean out the html entities
		long = long:gsub("&#%d%d;", ":")                -- clean out the html entities
		-- read the latitude numbers into a table
		for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
  			lat_long[#lat_long + 1] = num
		end
		-- add the N/S
		lat_long[#lat_long + 1] = lat:sub(-1)
		-- read the longitude numbers into a table
		for num in mw.ustring.gmatch(long, "%d+%.?%d*") do
			lat_long[#lat_long + 1] = num
		end
		-- add E/W for long
		lat_long[#lat_long + 1] = long:sub(-1)
		-- add named parameter for display
		lat_long["display"] = disp
		-- invoke template Coor dms with the values stored in the table
		return frame:expandTemplate{title = 'Coor dms', args = lat_long}
	end
end


-------------------------------------------------------------------------------
-- getQualifierValue is used to get a formatted value of a qualifier
-- 
-- The call needs:	a property (the unnamed parameter or 1=)
-- 					a target value for that property (pval=)
--					a qualifier for that target value (qual=)
-- The usual whitelisting and blacklisting of the property is implemented
-- The boolean onlysourced= parameter can be set to return nothing
-- when the property is unsourced (or only sourced to Wikipedia)
-- 
p.getQualifierValue = function(frame)
	local propertyID = mw.text.trim(frame.args[1] or "")

	-- The PropertyID of the target value of the property
	-- whose qualifier is to be returned is passed in named parameter |pval=
	local propvalue = frame.args.pval
	
	-- The PropertyID of the qualifier
	-- whose value is to be returned is passed in named parameter |qual=
	local qualifierID = frame.args.qual

	-- onlysourced is a boolean passed to return qualifiers
	-- only when property values are sourced to something other than Wikipedia
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or 0 is passed set it false
	local onlysrc = parseParam(frame.args.onlysourced,false)
	
	local success, errorOrEntity, props = parseInput(frame,nil, propertyID)
	if not success then
		return errorOrEntity
	else
		local entity = errorOrEntity
		-- Scan through the values of the property
		-- we want something like property is P793, significant event (in propertyID)
		-- whose value is something like Q385378, construction (in propvalue)
		-- then we can return the value(s) of a qualifier such as P580, start time (in qualifierID)
		for k1, v1 in pairs(props) do
			if v1.mainsnak.snaktype == "value" and v1.mainsnak.datavalue.type == "wikibase-entityid" then
				-- It's a wiki-linked value, so check if it's the target (in propvalue)
				-- and if it has qualifiers
				if v1.mainsnak.datavalue.value.id == propvalue and v1.qualifiers then
					if (onlysrc == true) and not sourced(v1) then
						return
					end
					-- if we've got this far, we have a (sourced) claim with qualifiers
					-- which matches the target, so find the value(s) of the qualifier we want
					local quals = v1.qualifiers[qualifierID]
					local out = {}
					if quals then
						if quals[1].datatype == "wikibase-item" then
							for k2, v2 in pairs(quals) do
								local valueID = v2.datavalue.value.id
								local sitelink = mw.wikibase.sitelink(valueID)
								local label = labelOrId(valueID,frame.args.idioma or "pt-br")
								if sitelink then
									out[#out + 1] = "[[" .. sitelink .. "|" .. label .. "]]"
								else
									out[#out + 1] = "[[:d:" .. valueID .. "|" .. label .. "]] <span title='" .. i18n["errors"]["local-article-not-found"] .. "'>[[Ficheiro:Wikidata-logo.svg|16px|alt=|link=]]</span>"
								end
							end
							return table.concat(out, ", ")
						else
							return mw.wikibase.renderSnaks(quals)
						end
					end
				end
			end -- of loop through values of propertyID
		end
	end
	return nil
end

-------------------------------------------------------------------------------
-- getLink returns the label for a Qid wiki-linked to the local article (if the article exists)
-- if label doesn't exist, it returns the Qid wiki-linked to the local article (if the article exists)
--
p.getLink = function(frame)
	local itemID = mw.text.trim(frame.args[1] or "")
	if itemID == "" then return end
	local sitelink = mw.wikibase.sitelink(itemID)
	local idioma = frame.args.idioma or "pt-br"
	local label = labelOrId(itemID,idioma)
	if sitelink then
		return "[[" .. sitelink .. "|" .. label .. "]]"
	else
		return label
	end
end

-------------------------------------------------------------------------------
-- getID returns the qid for the local article (if the article has one)
-- if qid doesn't exist, it returns an empty string
--
p.getID = function()
	local entity = mw.wikibase.getEntityObject()
	
	if entity == nil then
		return ""
	end
	return entity.id
end


-------------------------------------------------------------------------------
-- getLabel returns the label for a Qid
-- if label doesn't exist, it returns the Qid
--
p.getLabel = function(frame)
	local itemID = mw.text.trim(frame.args[1] or "")
	if itemID == "" then return end
	return labelOrId(itemID,frame.args.idioma or "pt-br")
end


-------------------------------------------------------------------------------
-- getAT returns the article title for a Qid
-- or nothing if it doesn't exist
--
p.getAT = function(frame)
	local itemID = mw.text.trim(frame.args[1] or "")
	if itemID == "" then return end
	return mw.wikibase.sitelink(itemID)
end

-------------------------------------------------------------------------------
-- getSitelink returns the article title for a Qid in a globalSiteId wiki (like "enwiki" or "ptwiki")
-- or nothing if it doesn't exist
--
p.getSitelink = function(frame)
	local itemID = mw.text.trim(frame.args[1] or "")
	local globalSiteId = mw.text.trim(frame.args[2] or "")
	return mw.wikibase.sitelink(itemID,globalSiteId)
end

local _getSitelink = function(qid,wiki)
	local qid = qid or ""
	local wiki = wiki or ""
	return mw.wikibase.sitelink(qid,wiki)
end

-------------------------------------------------------------------------------
-- formatDate is a wrapper to export the private function format_Date
--
p.formatDate = function(frame)
	return format_Date(frame,frame.args[1], frame.args.df, frame.args.bc,frame.args.idioma, frame.args.datasemlink)
end

-------------------------------------------------------------------------------
-- checkBlacklist allows a test to check whether a named field is suppressed
-- {{#if:{{#invoke:WikidataIB |checkBlacklist |name=Joe |suppressfields=Dave; Joe; Fred}} | not blacklisted | blacklisted}}
-- displays "blacklisted"
-- {{#if:{{#invoke:WikidataIB |checkBlacklist |name=Jim |suppressfields=Dave; Joe; Fred}} | not blacklisted | blacklisted}}
-- displays "not blacklisted"
--
p.checkBlacklist = function(frame)
	local blacklist = frame.args.suppressfields
	local fieldname = frame.args.name
	if blacklist and fieldname then
		if blacklist:find(fieldname) then return nil end
		return true
	end
end

p.predMorte = function(frame)
	local result1 = {}
	local result2 = {}
	local idioma
	
	for word in string.gmatch(frame.args[1],"[^|]+") do
		result1[#result1+1] = word
	end
	for word2 in string.gmatch(frame.args[2],"[^|]+") do
		result2[#result2+1] = word2
	end
	if #result1 == 2 then
		result1[3] = result1[2]
		result1[2] = result1[1]
		result1[1] = ""
	elseif #result1 == 1 then
		result1[3] = result1[1]
		result1[2] = ""
		result1[1] = ""
	end
	if #result2 == 2 then
		result2[3] = result2[2]
		result2[2] = result2[1]
		result2[1] = ""
	elseif #result2 == 1 then
		result2[3] = result2[1]
		result2[2] = ""
		result2[1] = ""
	end

	if frame.args.idioma == "pt-ao" then
		idioma = "ao"
	else
		idioma = "br"
	end
	
	if (result1[1]=="Desconhecido") or (result1[2]== "Desconhecido") or (result1[3]== "Desconhecido") then
		return "Desconhecido"
	else
		if (result2[1]=="Desconhecido") or (result2[2]== "Desconhecido") or (result2[3]== "Desconhecido") then
			return frame:expandTemplate{ title = 'Morte', args = {result1[1],result1[2],result1[3],lang = idioma}}
		else
			return frame:expandTemplate{ title = 'Morte', args = {result1[1],result1[2],result1[3],result2[1],result2[2],result2[3],lang = idioma}}
		end
	end
end

p.predDni = function(frame)
	local result = {}
	local idioma
	local comidade = frame.args[2] or ""
	for word in string.gmatch(frame.args[1],"[^|]+") do
		result[#result+1] = word
	end
	if #result == 2 then
		result[3] = result[2]
		result[2] = result[1]
		result[1] = ""
	elseif #result == 1 then
		result[3] = result[1]
		result[2] = ""
		result[1] = ""
	elseif #result == 0 then
		result[3] = ""
		result[2] = ""
		result[1] = ""
	end
	
	if frame.args.idioma == "pt-ao" then
		idioma = "ao"
	else
		idioma = "br"
	end
	
	if (result[1]=="Desconhecido") or (result[2]== "Desconhecido") or (result[3]== "Desconhecido") then
		return "Desconhecido"
	end
	
	if result[3]~="" and tonumber(result[3])<1900 then
		comidade = "si"
	end
	
	if string.match(result[3], "-") then
		result[3] = string.gsub(result[3], "-", "")
		result[3] = result[3].." a.C."
	end

	if comidade then
		return frame:expandTemplate{ title = 'Dni', args = {result[1],result[2],result[3],comidade,lang = idioma}}
	else
		return frame:expandTemplate{ title = 'Dni', args = {result[1],result[2],result[3],lang = idioma}}
	end
end

p.getValueQualIndirect = function(frame)
	local propertyID = mw.text.trim(frame.args[1] or "")

	-- The PropertyID of the qualifier
	-- whose value is to be returned is passed in named parameter |qual=
	local qualifierID = frame.args.qual

	-- onlysourced is a boolean passed to return qualifiers
	-- only when property values are sourced to something other than Wikipedia
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or 0 is passed set it false
	local onlysrc = parseParam(frame.args.onlysourced,false)
	
	local artigosemlink = frame.args.artigosemlink or "não"
	
	local success, errorOrEntity, props = parseInput(frame,nil, propertyID)
	if not success then
		return errorOrEntity
	else
		local entity = errorOrEntity
		-- Scan through the values of the property
		-- we want something like property is P793, significant event (in propertyID)
		-- whose value is something like Q385378, construction (in propvalue)
		-- then we can return the value(s) of a qualifier such as P580, start time (in qualifierID)
		
		local sep = frame.args.sep or ", "
		local out = {}
		local onlyvalue = frame.args.onlyvalue or ""
		local comlink = frame.args.comlink or ""
		
		for k1, v1 in pairs(props) do
			if v1.mainsnak.snaktype == "value" then --and v1.mainsnak.datavalue.type == "wikibase-entityid" then
				-- It's a wiki-linked value, so check if it's the target (in propvalue)
				-- and if it has qualifiers
				if v1.mainsnak.datatype == "wikibase-item" then
					local propid = v1.mainsnak.datavalue.value.id
					local propsitelink = mw.wikibase.sitelink(propid)
					local proplabel = labelOrId(propid,frame.args.idioma or "pt-br")
					if propsitelink then
						if propsitelink == proplabel then
							propvalue = "[["..propsitelink.."]]"
						else
							propvalue = "[["..propsitelink.."|"..proplabel.."]]"
						end
					else
						if comlink == "sim" then 
							propvalue = "[["..proplabel.."]]"
						else 
							propvalue = proplabel
						end
					end
				end --elseif quantity, url etc TODO
				if v1.qualifiers then --v1.mainsnak.datavalue.value.id == propvalue and 
					if (onlysrc == true) and not sourced(v1) then
						return
					end
					-- if we've got this far, we have a (sourced) claim with qualifiers
					-- which matches the target, so find the value(s) of the qualifier we want
					local quals = v1.qualifiers[qualifierID]
					if quals then
						local sep_qual = frame.args.sep_qual or ": "
						local sep_inter_qual = frame.args.sep_inter_qual or ", "
						local valuequal = {}
						local postfix = frame.args.postfix or ""
						if quals[1].datatype == "wikibase-item" then
							for k2, v2 in pairs(quals) do
								local valueID = v2.datavalue.value.id
								local sitelink = mw.wikibase.sitelink(valueID)
								local label = labelOrId(valueID,frame.args.idioma or "pt-br")
								if sitelink then
									if sitelink ~= label then
										if artigosemlink == "sim" then
											valuequal[#valuequal+1] = sitelink..postfix
										else
											valuequal[#valuequal+1] = "[[" .. sitelink .. "|" .. label .. "]]"..postfix
										end
									else
										if artigosemlink == "sim" then
											valuequal[#valuequal+1] = sitelink..postfix
										else
											valuequal[#valuequal+1] = "[["..label.."]]"..postfix
										end
									end
								else
									if artigosemlink == "sim" then
										valuequal[#valuequal+1] = label..postfix
									else
										valuequal[#valuequal+1] = "[["..label.."]]"..postfix
									end
								end
							end
							if onlyvalue == "sim" then 
								out[#out+1] = table.concat(valuequal, sep_inter_qual)
							else 
								out[#out+1] = propvalue .. sep_qual .. table.concat(valuequal, sep_inter_qual)
							end
						else
							for k2, v2 in pairs(quals) do
								valuequal[#valuequal+1] = mw.wikibase.renderSnak(v2)..postfix
							end
							if onlyvalue == "sim" then 
								out[#out+1] = table.concat(valuequal, sep_inter_qual)
							else
								out[#out+1] = propvalue .." ".. sep_qual .. table.concat(valuequal, sep_inter_qual)
							end
						end
					end
				end
			end -- of loop through values of propertyID
			
		end
		return table.concat(out, sep)
	end
	return nil
end

p.getValueIndirect = function(frame)
	local property1 = mw.text.trim(frame.args[1] or "")
	local property2 = mw.text.trim(frame.args[2] or "")
	
	-- Can take a named parameter |qid which is the Wikidata ID for the article.
	-- This will not normally be used because it's an expensive call.
	local qid1 = frame.args.qid
	if qid1 and (#qid1 == 0) then qid1 = nil end

	local entity1 = mw.wikibase.getEntityObject(qid1)
	local props1
	if entity1 and entity1.claims then
		props1 = entity1.claims[property1]
	end
	
	local out = {}
	local oo = {}
	local sep = frame.args.sep or ","
	if props1 then
		-- Check that the first value of the property is a wikibase-item
		for k1, v1 in pairs(props1) do
			if v1.mainsnak.datatype == "wikibase-item" then
				local qid2 = v1.mainsnak.datavalue.value.id
				local entity2 = mw.wikibase.getEntityObject(qid2)
				if entity2.claims then
					-- only need props2 if we want a more sophisticated parsing, e.g. mdy dates
					-- local props2 = entity2.claims[property2]
					out[#out+1] = entity2:formatPropertyValues(property2).value
				else
					out[#out+1] = qid2 .. " has no claims."
				end
			else
				out[#out+1] = "not wikibase-item: " .. v1.mainsnak.datatype --debug
			end
		end
	end
	return table.concat(out, sep.." ")
end

-------------------------------------------------------------------------------
-- _getCommonslink takes an optional qid of a Wikidata entity passed as |qid=
-- It returns one of the following in order of preference:
-- 	the Commons sitelink of the linked Wikidata item;
-- 	the Commons sitelink of the topic's main category of the linked Wikidata item;
-- 	the Commons category.
-- If the optional parameter onlycat is true/yes/1 then only categories are returned
-- defaults to false.
-------------------------------------------------------------------------------
-- Dependencies: _getSitelink(); parseParam()
-------------------------------------------------------------------------------
local _getCommonslink = function(qid, onlycat, fallback)
	qid = (qid or ""):upper()
	if qid == "" then qid = mw.wikibase.getEntityIdForCurrentPage() end
	if not qid then return nil end
	onlycat = parseParam(onlycat, false)
	local sitelink = _getSitelink(qid, "commonswiki")
	if onlycat and sitelink and sitelink:sub(1,9) ~= "Category:" then sitelink = nil end
	if not sitelink then
		-- check for topic's main category
		local prop910 = mw.wikibase.getBestStatements(qid, "P910")[1]
		if prop910 then
			local tmcid = prop910.mainsnak.datavalue.value.id
			sitelink = _getSitelink(tmcid, "commonswiki")
		end
	end
	if not sitelink and fallback then
		-- check for Commons category (string value)
		local prop373 = mw.wikibase.getBestStatements(qid, "P373")[1]
		if prop373 then
			sitelink = prop373.mainsnak.datavalue.value
			if sitelink then sitelink = "Category:" .. sitelink end
		end
	end
	return sitelink
end

-------------------------------------------------------------------------------
-- getCommonsLink takes an optional qid of a Wikidata entity passed as |qid=
-- It returns one of the following in order of preference:
-- the Commons sitelink of the linked Wikidata item;
-- the Commons sitelink of the topic's main category of the linked Wikidata item;
-------------------------------------------------------------------------------
-- Dependencies: _getCommonslink(); _getSitelink(); parseParam()
-------------------------------------------------------------------------------
p.getCommonsLink = function(frame)
	local oc = frame.args.onlycat or frame.args.onlycategories
	local fb = parseParam(frame.args.fallback or frame.args.fb, true)
	return _getCommonslink(frame.args.qid, oc, fb)
end

-------------------------------------------------------------------------------
local ArtsIDs = {
	['P347'] = 'http://www.culture.gouv.fr/public/mistral/joconde_fr?ACTION=CHERCHER&FIELD_1=REF&VALUE_1=$1',
	['P350'] = 'https://rkd.nl/explore/images/$1',
	['P1212'] = 'http://cartelfr.louvre.fr/cartelfr/visite?srv=car_not_frame&idNotice=$1',
	['P1428'] = 'http://www.lostart.de/EN/Verlust/$1',
	['P1679'] = 'https://artuk.org/discover/artworks/$1',
	['P1726'] = 'http://www.polomuseale.firenze.it/inv1890/scheda.asp?position=1&ninv=$1',
	['P2014'] = 'http://www.moma.org/collection/works/$1',
	['P2092'] = 'http://www.bildindex.de/obj$1.html',
	['P2108'] = 'https://www.kulturarv.dk/kid/VisVaerk.do?vaerkId=$1',
	['P2242'] = 'http://www.polomuseale.firenze.it/catalogo/scheda.asp?nctn=$1&value=1',
	['P2282'] = 'http://groeningemuseum.be/collection/work/id/$1',
	['P2344'] = 'http://www.purl.org/inha/agorha/003/$1',
	['P2511'] = 'http://mskgent.be/collection/work/id/$1',
	['P2539'] = 'http://collection.nationalmuseum.se/eMuseumPlus?service=ExternalInterface&module=collection&objectId=$1&viewType=detailView',
	['P2582'] = 'http://www.getty.edu/art/collection/objects/$1',
	['P3272'] = 'http://catalogo.fondazionezeri.unibo.it/scheda/opera/$1/',
	['P3293'] = 'http://balat.kikirpa.be/object/$1',
	['P3386'] = 'http://frenchsculpture.org/sculpture/$1',
	['P3386'] = 'https://frenchsculpture.org/fr/sculpture/$1',
	['P3467'] = 'http://www.polomuseale.firenze.it/invSculture/scheda.asp?position=1&ninv=$1',
	['P3504'] = 'http://www.polomuseale.firenze.it/invpalatina/scheda.asp?position=1&ninv=$1',
	['P3634'] = 'http://www.metmuseum.org/art/collection/search/$1',
	['P3711'] = 'http://vanderkrogt.net/statues/object.php?record=$1',
	['P3855'] = 'http://www.lombardiabeniculturali.it/opere-arte/schede/$1/',
	['P3929'] = 'http://collections.vam.ac.uk/item/$1',
	['P4144'] = 'http://www.the-athenaeum.org/art/detail.php?id=$1',
	['P4257'] = 'http://www.emuseum.jp/detail/$1',
	['P4373'] = 'http://www.nationaltrustcollections.org.uk/object/$1',
	['P4380'] = 'http://ta.sandrart.net/-artwork-$1',
	['P4399'] = 'http://enciclopedia.itaucultural.org.br/$1',
	['P4525'] = 'http://opendata.muis.ee/object/$1',
	['P4564'] = 'https://digikogu.ekm.ee/oid-$1',
	['P4582'] = 'https://www.kulturelles-erbe-koeln.de/documents/obj/$1',
	['P4610'] = 'https://www.artic.edu/artworks/$1',
	['P4611'] = 'https://collections.lacma.org/node/$1',
	['P4625'] = 'http://www.mfa.org/collections/object/$1',
	['P4643'] = 'http://www.philamuseum.org/collections/permanent/$1.html',
	['P4659'] = 'http://www.musee-orsay.fr/en/collections/index-of-works/notice.html?nnumid=$1',
	['P4659'] = 'http://www.musee-orsay.fr/fr/collections/catalogue-des-oeuvres/notice.html?nnumid=$1',
	['P4673'] = 'https://www.mfah.org/art/detail/$1',
	['P4674'] = 'http://collection.imamuseum.org/artwork/$1/',
	['P4683'] = 'https://www.nga.gov/content/ngaweb/Collection/art-object-page.$1.html',
	['P4684'] = 'https://www.ngv.vic.gov.au/explore/collection/work/$1/',
	['P4686'] = 'https://collection.cmoa.org/objects/$1',
	['P4692'] = 'http://browse.americanartcollaborative.org/object/$1.html',
	['P4701'] = 'https://www.google.com/culturalinstitute/beta/asset/wd/$1',
	['P4704'] = 'https://americanart.si.edu/collections/search/artwork/?id=$1',
	['P4709'] = 'https://collection.barnesfoundation.org/objects/$1/details',
	['P4712'] = 'https://collections.artsmia.org/art/$1',
	['P4713'] = 'http://art.thewalters.org/detail/$1',
	['P4721'] = 'http://mubevirtual.com.br/pt_br?Dados&area=ver&id=$1',
	['P4737'] = 'https://www.guggenheim.org/artwork/$1',
	['P4738'] = 'http://collections.britishart.yale.edu/vufind/Record/$1',
	['P4739'] = 'https://www.augustins.org/fr/oeuvre/-/oeuvre/$1',
	['P4740'] = 'https://www.brooklynmuseum.org/opencollection/objects/$1',
	['P4761'] = 'http://art.rmngp.fr/en/library/artworks/$1',
	['P4761'] = 'http://art.rmngp.fr/fr/library/artworks/$1',
	['P4764'] = 'http://www.culture.gouv.fr/public/mistral/arcade_fr?ACTION=CHERCHER&FIELD_1=REF&VALUE_1=$1',
	['P4814'] = 'https://siris-artinventories.si.edu/ipac20/ipac.jsp?&menu=search&index=.NW&term=$1',
	['P4905'] = 'http://kmska.be/collection/work/id/$1',
	['P5210'] = 'http://www.gallery.am/en/database/item/$1/',
	['P5223'] = 'http://museum.imj.org.il/artcenter/includes/item.asp?id=$1',
	['P5265'] = 'https://www.dordrechtsmuseum.nl/objecten/id/$1',
	['P5268'] = 'http://acervo.mnav.gub.uy/obras.php?q=ni:$1',
	['P5269'] = 'https://www.webumenia.sk/dielo/$1',
	['P5407'] = 'http://datenbank.museum-kassel.de/$1',
	['P5499'] = 'http://collectie.boijmans.nl/en/collection/artworks/$1',
	['P5783'] = 'http://lucascranach.org/$1',
	['P5823'] = 'https://digital.belvedere.at/objects/$1/',
	['P5891'] = 'http://www.bpk-images.de/id/$1',
	['P6004'] = 'https://www.brasilianaiconografica.art.br/obras/$1/wd',
	['P6007'] = 'http://salons.musee-orsay.fr/index/notice/$1',
	['P6020'] = 'https://www.france.tv/france-2/d-art-d-art/$1.html',
	['P6141'] = 'https://anosgrandshommes.musee-orsay.fr/index.php/Detail/objects/$1',
	['P6152'] = 'http://npg.si.edu/object/npg_$1',
	['P6238'] = 'https://monumentsmorts.univ-lille.fr/monument/$1/wd/',
	['P6239'] = 'https://monuments.iec.cat/fitxa.asp?id=$1',
	['P6246'] = 'http://parismuseescollections.paris.fr/en/node/$1',
	['P6246'] = 'http://parismuseescollections.paris.fr/fr/node/$1',
	['P6246'] = 'http://parismuseescollections.paris.fr/es/node/$1',
	['P6310'] = 'http://museosphere.paris.fr/oeuvres/$1',
	['P6332'] = 'https://www.panoramadelart.com/$1',
	['P6355'] = 'https://collection.centrepompidou.fr/#/artwork/$1',
	['P6356'] = 'http://www.ihoi.org/app/photopro.sk/ihoi_icono/detail?docid=$1&lang=eng',
	['P6358'] = 'https://www.navigart.fr/picassoparis/#/artwork/$1',
	['P6372'] = 'https://www.interpol.int/notice/search/woa/$1',
	['P6374'] = 'http://www.mam.paris.fr/en/online-collections#/artwork/$1'
}

-------------------------------------------------------------------------------
-- getArtIdentifiers takes an optional qid of a Wikidata entity passed as |qid=
-- It returns all art identifiers of that entity
-------------------------------------------------------------------------------
function p.getArtIdentifiers(frame)
	local qid = frame.args.qid or ""
	if qid == "" then qid = mw.wikibase.getEntityIdForCurrentPage() end
	local entity = mw.wikibase.getEntityObject(qid)
	local props
	local out = {}
	
	for k, v in pairs(ArtsIDs) do
		if entity and entity.claims[k] then
			props = entity.claims[k]
			for k2, v2 in pairs(props) do
				if v2.mainsnak.snaktype ~= 'novalue' then
					out[#out+1] = '[' .. mw.ustring.gsub(v, '$1', v2.mainsnak.datavalue.value) .. ']'
				end
			end
		end
	end
	
	return table.concat(out,"")
end

return p