Selle mooduli dokumentatsiooni saab kirjutada asukohta Moodul:WikidataDev/doc.

-- testimisjärgus Wikidata funktsioonid

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

-- internationalisation
local i18n = {
    ["errors"] = {
        ["property-not-found"] = "Omadust ei leitud.",
        ["entity-not-found"] = "Wikidata andmeüksust ei leitud.",
        ["unknown-claim-type"] = "Unknown claim type.",
        ["unknown-snak-type"] = "Unknown snak type.",
        ["unknown-datavalue-type"] = "Unknown datavalue type.",
        ["unknown-entity-type"] = "Unknown entity type.",
        ["qualifier-not-found"] = "Qualifier not found."
    },
    ["somevalue"] = "''tundmatu väärtus''",
    ["novalue"] = "''väärtus puudub''",
    ["datetime"] =
	{
		-- $1 is a placeholder for the actual number
		[0] = "$1 mld aastat",		-- precision: billion years
		[1] = "$100 mln aastat",	-- precision: hundred million years
		[2] = "$10 mln aastat",	-- precision: ten million years
		[3] = "$1 mln aastat",		-- precision: million years
		[4] = "$100.000 aastat",	-- precision: hundred thousand years
		[5] = "$10.000 aastat",		-- precision: ten thousand years
		[6] = "$1. aastatuhat", 	-- precision: millenium
		[7] = "$1. sajand",	-- precision: century
		[8] = "$1er",			-- precision: decade
		-- the following use the format of #time parser function
		[9]  = "Y",			-- precision: year, 
		[10] = "F Y",			-- precision: month
		[11] = "j. F Y",		-- precision: day
		[12] = 'j. F Y, "kell" G',	-- precision: hour
		[13] = "j. F Y G:i",		-- precision: minute
		[14] = "j. F Y G:i:s",		-- precision: second
		["beforenow"] = "vor $1",	-- how to format negative numbers for precisions 0 to 5
		["afternow"] = "in $1",		-- how to format positive numbers for precisions 0 to 5
		["bc"] = '$1 "eKr."',		-- how print negative years
		["ad"] = "$1"			-- how print positive years
	}
}

local p = { }

local function printError(code)
	return '<span class="error">' .. i18n.errors[code] .. '</span>'
end

-- the "qualifiers" and "snaks" field have a respective "qualifiers-order" and "snaks-order" field
-- use these as the second parameter and this function instead of the built-in "pairs" function
-- to iterate over all qualifiers and snaks in the intended order.
local function orderedpairs(array, order)
	if not order then return pairs(array) end
	
	-- return iterator function
    local i = 0
    return function()
        i = i + 1
        if order[i] then
            return order[i], array[order[i]]
        end
    end	
end

function p.descriptionIn(frame)
	local langcode = frame.args[1]
	-- return description of a Wikidata entity in the given language or the default language of this Wikipedia site
	return mw.wikibase.getEntityObject().descriptions[langcode or wiki.langcode].value
end

function p.labelIn(frame)
	local langcode = frame.args[1]
	-- return label of a Wikidata entity in the given language or the default language of this Wikipedia site
	return mw.wikibase.getEntityObject().labels[langcode or wiki.langcode].value
end

local function printDatavalueCoordinate(data, parameter)
	-- data fields: latitude [double], longitude [double], altitude [double], precision [double], globe [wikidata URI, usually http://www.wikidata.org/entity/Q2 [earth]]
	if parameter then
		if parameter == "globe" then data.globe = mw.ustring.match(data.globe, "Q%d+") end -- extract entity id from the globe URI
		return data[parameter]
	else
		return data.latitude .. "/" .. data.longitude -- combine latitude and longitude, which can be decomposed using the #titleparts wiki function
	end
end

local function printDatavalueQuantity(data, parameter)
	-- data fields: amount [number], unit [string], upperBound [number], lowerBound [number]
	if parameter then
		return data[paramater]
	else
		return tonumber(data.amount)
	end
end

-- precision: 0 - billion years, 1 - hundred million years, ..., 6 - millenia, 7 - century, 8 - decade, 9 - year, 10 - month, 11 - day, 12 - hour, 13 - minute, 14 - second
local function normalizeDate(date)
	date = mw.text.trim(date, "+")
	-- extract year
	local yearstr = mw.ustring.match(date, "^\-?%d+")
	local year = tonumber(yearstr)
	-- remove leading zeros of year
	return year .. mw.ustring.sub(date, #yearstr + 1), year
end

function formatDate(date, precision, timezone)
	precision = precision or 11
	date, year = normalizeDate(date)
	if year == 0 and precision <= 9 then return "" end
 
 	-- precision is 10000 years or more
	if precision <= 5 then
		local factor = 10 ^ ((5 - precision) + 4)
		local y2 = math.ceil(math.abs(year) / factor)
		local relative = mw.ustring.gsub(i18n.datetime[precision], "$1", tostring(y2))
		if year < 0 then
			relative = mw.ustring.gsub(i18n.datetime.beforenow, "$1", relative)
		else
			relative = mw.ustring.gsub(i18n.datetime.afternow, "$1", relative)
		end			
		return relative
	end
 
 	-- precision is decades, centuries and millenia
	local era
	if precision == 6 then era = mw.ustring.gsub(i18n.datetime[6], "$1", tostring(math.floor((math.abs(year) - 1) / 1000) + 1)) end
	if precision == 7 then era = mw.ustring.gsub(i18n.datetime[7], "$1", tostring(math.floor((math.abs(year) - 1) / 100) + 1)) end
	if precision == 8 then era = mw.ustring.gsub(i18n.datetime[8], "$1", tostring(math.floor(math.abs(year) / 10) * 10)) end
	if era then
		if year < 0 then era = mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.bc, '"', ""), "$1", era)
		elseif year > 0 then era = mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.ad, '"', ""), "$1", era) end
		return era
	end
	
	-- precision is years or less
	if precision >= 9 then
		--[[ the following code replaces the UTC suffix with the given negated timezone to convert the global time to the given local time
		timezone = tonumber(timezone)
		if timezone and timezone ~= 0 then
			timezone = -timezone
			timezone = string.format("%.2d%.2d", timezone / 60, timezone % 60)
			if timezone[1] ~= '-' then timezone = "+" .. timezone end
			date = mw.text.trim(date, "Z") .. " " .. timezone
		end
		]]--
		
		local formatstr = i18n.datetime[precision]
		if year == 0 then formatstr = mw.ustring.gsub(formatstr, i18n.datetime[9], "")
		elseif year < 0 then
			-- Mediawiki formatDate doesn't support negative years
			date = mw.ustring.sub(date, 2)
			formatstr = mw.ustring.gsub(formatstr, i18n.datetime[9], mw.ustring.gsub(i18n.datetime.bc, "$1", i18n.datetime[9]))
		elseif year > 0 and i18n.datetime.ad ~= "$1" then
			formatstr = mw.ustring.gsub(formatstr, i18n.datetime[9], mw.ustring.gsub(i18n.datetime.ad, "$1", i18n.datetime[9]))
		end
		return mw.language.new(wiki.langcode):formatDate(formatstr, date)
	end
end

local function printDatavalueTime(data, parameter)
	-- data fields: time [ISO 8601 time], timezone [int in minutes], before [int], after [int], precision [int], calendarmodel [wikidata URI]
	--   precision: 0 - billion years, 1 - hundred million years, ..., 6 - millenia, 7 - century, 8 - decade, 9 - year, 10 - month, 11 - day, 12 - hour, 13 - minute, 14 - second
	--   calendarmodel: e.g. http://www.wikidata.org/entity/Q1985727 for the proleptic Gregorian calendar or http://www.wikidata.org/wiki/Q11184 for the Julian calendar]
	if parameter then
		if parameter == "calendarmodel" then data.calendarmodel = mw.ustring.match(data.calendarmodel, "Q%d+") -- extract entity id from the calendar model URI
		elseif parameter == "time" then data.time = normalizeDate(data.time) end
		return data[parameter]
	else
		return formatDate(data.time, data.precision, data.timezone)
	end
end

local function printDatavalueEntity(data, parameter)
	-- data fields: entity-type [string], numeric-id [int, Wikidata id]
	if parameter then
		return data[parameter]
	else
		if data["entity-type"] == "item" then return mw.wikibase.label("Q" .. data["numeric-id"]) else printError("unknown-entity-type") end
	end
end

function findClaims(entity, property)
	if not property or not entity or not entity.claims then return end
	
	if mw.ustring.match(property, "^P%d+$") then
		-- if the property is given by an id (P..) access the claim list by this id
		return entity.claims[property]
	else
		property = mw.wikibase.resolvePropertyId(property)
		if not property then return end

		return entity.claims[property]
	end
end

function getSnakValue(snak, parameter)
	-- snaks have three types: "novalue" for null/nil, "somevalue" for not null/not nil, or "value" for actual data
	if snak.snaktype == "novalue" then return i18n["novalue"]
	elseif snak.snaktype == "somevalue" then return i18n["somevalue"]
	elseif snak.snaktype ~= "value" then return nil, printError("unknown-snak-type")
	end
		
	-- call the respective snak parser
	if snak.datavalue.type == "string" then return snak.datavalue.value
	elseif snak.datavalue.type == "globecoordinate" then return printDatavalueCoordinate(snak.datavalue.value, parameter)
	elseif snak.datavalue.type == "quantity" then return printDatavalueQuantity(snak.datavalue.value, parameter)
	elseif snak.datavalue.type == "time" then return printDatavalueTime(snak.datavalue.value, parameter)
	elseif snak.datavalue.type == "wikibase-entityid" then return printDatavalueEntity(snak.datavalue.value, parameter)
	else return nil, printError("unknown-datavalue-type")
	end
end

function getQualifierSnak(claim, qualifierId)
	-- a "snak" is Wikidata terminology for a typed key/value pair
	-- a claim consists of a main snak holding the main information of this claim,
	-- as well as a list of attribute snaks and a list of references snaks
	if qualifierId then
		-- search the attribute snak with the given qualifier as key
		if claim.qualifiers then
			local qualifier = claim.qualifiers[qualifierId]
			if qualifier then return qualifier[1] end
		end
		return nil, printError("qualifier-not-found")
	else
		-- otherwise return the main snak
		return claim.mainsnak
	end
end

function getValueOfClaim(claim, qualifierId, parameter)
	local error
	local snak
	snak, error = getQualifierSnak(claim, qualifierId)
	if snak then
		return getSnakValue(snak, parameter)
	else
		return nil, error
	end
end

function getReferences(claim)
	local result = ""
 
	-- traverse through all references
	for ref in pairs(claim.references or {}) do
		local refparts = "" 
		local outtext = ""
		local desc = ""
		local accessed = ""
		local url = ""
		-- traverse through all parts of the current reference
		for snakkey, snakval in orderedpairs(claim.references[ref].snaks or {}, claim.references[ref]["snaks-order"]) do
			local currentref = ""
			if #refparts > 0 then refparts = refparts .. ", " end
			-- output all values of this reference part, e.g. "German Wikipedia" and "English Wikipedia" if the referenced claim was imported from both sites
			for snakidx = 1, #snakval do
				if snakidx > 1 then currentref = currentref .. ", " end
				if getSnakValue(snakval[snakidx]) then currentref = currentref .. getSnakValue(snakval[snakidx]) end
			end
			refparts = refparts .. currentref
			if snakkey == 'P248' then
				desc = currentref
			elseif snakkey == 'P813' then
				accessed = currentref
			elseif snakkey == 'P854' then 
				url = currentref
			end
		end
		if #url > 0 then
			if #desc > 0 then
				outtext = "[" .. url .. " " .. desc .. "]"
			else
				outtext = url
			end
			if #accessed > 0 then
				outtext = outtext .. ", vaadatud " .. accessed
			end
			result = result .. "<ref>" .. outtext .. "</ref>"
		elseif refparts then result = result .. "<ref>" .. refparts .. "</ref>" 
		end
	end
	return result
end

function p.claim(frame)
	local property = frame.args[1] or ""
	local qualifierId = frame.args["qualifier"]
	local parameter = frame.args["parameter"]
	local list = frame.args["list"]
	local references = frame.args["references"]
	local showerrors = frame.args["showerrors"]
	local sortby = frame.args["sortby"]
	local order = frame.args["order"]

	-- get wikidata entity
	local entity = mw.wikibase.getEntityObject()
	if not entity then
		if showerrors then return printError("entity-not-found") else return end
	end
	-- fetch the first claim of satisfying the given property
	local claims = findClaims(entity, property)
	if not claims or not claims[1] then
		if showerrors then return printError("property-not-found") else return end
	end
		
	-- get initial sort indices
	local sortindices = {}
	for idx in pairs(claims) do
		sortindices[#sortindices + 1] = idx
	end
	-- sort by claim rank
	local comparator = function(a, b)
		--local rankmap = { deprecated = -1, normal = 0, preferred = 1 } -- not needed as the ranks are coincidentally in alphanumeric order 
		local ranka
		local rankb
		if sortby and mw.ustring.match(sortby, "^P%d+$") then
			-- FIXME time parameter should only be used on qualifiers of datetime value type
			local qParameter = "time"
			-- FIXME "!" on missing values?
			local onMissing = "!"
			ranka, error =  getValueOfClaim(claims[a], sortby, qParameter) or onMissing
			rankb, error =  getValueOfClaim(claims[b], sortby, qParameter) or onMissing
		else
			ranka = claims[a].rank or "normal"
			rankb = claims[b].rank or "normal"
			order = "desc"
		end
		order = order or "asc"
		if order == "asc" then
			return ranka < rankb
		else
			return ranka > rankb
		end

		--return mw.wikibase.label("Q" .. .mainsnak.datavalue.value["numeric-id"]) < mw.wikibase.label("Q" .. claims[b].mainsnak.datavalue.value["numeric-id"])
	end
	table.sort(sortindices, comparator)

	local result
	local error
	if list then
		local value
		-- iterate over all elements and return their value (if existing)
		for idx in pairs(claims) do
			local claim = claims[sortindices[idx]]
			if references == "only" then
				value = frame:preprocess(getReferences(claim))
				if result then
					if value then result = result .. list .. value end
				else
					result = value
				end				
			else
				value, error =  getValueOfClaim(claim, qualifierId, parameter)
				if not value and showerrors then value = error end
				if result then
					if value then result = result .. list .. value end
				else
					result = value
				end
				if value and references then result = result .. frame:preprocess(getReferences(claim)) end
			end
		end
	else
		-- return first element	
		local claim = claims[sortindices[1]]
		if references == "only" then
			result = frame:preprocess(getReferences(claim))
		else
			result, error = getValueOfClaim(claim, qualifierId, parameter)
			if result and references then result = result .. frame:preprocess(getReferences(claim)) end
		end
	end
	
	if not result and showerrors then return error else return result end
end

function p.pageId(frame)
	local entity = mw.wikibase.getEntityObject()
	if not entity then return nil else return entity.id end
end

function p.labelOf(frame)
	local id = frame.args[1]
	-- returns the label of the given entity/property id
	-- if no id is given, the one from the entity associated with the calling Wikipedia article is used
	if not id then
		local entity = mw.wikibase.getEntityObject()
		if not entity then return printError("entity-not-found") end
		id = entity.id
	end
	return mw.wikibase.label(id)
end

function p.sitelinkOf(frame)
	local id = frame.args[1]
	-- returns the Wikipedia article name of the given entity
	-- if no id is given, the one from the entity associated with the calling Wikipedia article is used
	if not id then
		local entity = mw.wikibase.getEntityObject()
		if not entity then return printError("entity-not-found") end
		id = entity.id
	end
	return mw.wikibase.sitelink(id)
end

-- call this in cases of script errors within a function instead of {{#invoke:Wikidata|<method>|...}} call {{#invoke:Wikidata|debug|<method>|...}}
function p.debug(frame)
	local func = frame.args[1]
	if func then
		table.remove(frame.args, 1)
		local status, result = pcall(p[func], frame)
		if status then return result else return '<span class="error">' .. result .. '</span>' end
	else
		return '<span class="error">invalid parameters</span>'
	end
end

function printTable(data, level)
	level = tonumber(level) or 0
	local result = ""
	local prefix = ""
	for idx = 1, level do prefix = prefix .. " " end
	
	if type(data) == "table" then
		for key, val in pairs(data) do
			result = result .. prefix .. key .. ": "
			if type(val) == "table" then result = result .. "\n" .. printTable(val, level + 1) else result = result .. tostring(val) .. "\n" end
		end
	else
		result = prefix .. tostring(data)
	end
	if level == 0 then result = "<pre>" .. mw.text.encode(result) .. "</pre>" end
	return result
end

function p.printEntity(frame)
	local entity = mw.wikibase.getEntityObject()
	return printTable(entity)
end

return p