Module:OfficeData

This is a derivative of Module:Wikidata specifically for working with Wikidata related to an office (the abstract function held by an officeholder).

Usage

{{#invoke:OfficeData|function_name}}

Functions

getPreferredOfficeholder

Returns the name of the preferred (incumbent) officeholder of the item. The preferred officeholder is found by sorting officeholder claims by rank.

getPreferredOfficeholderLink

Returns a link to the article about the preferred officeholder of the item.

getPreferredOfficeholderStarttime

Returns the start time of the term of the preferred officeholder of the item.

getPreferredOfficeholderCountry

Returns the country of the term of the preferred officeholder of the item.

getPreferredOfficeholderCountryLink

Returns a link to the country of the term of the preferred officeholder of the item.

---

------------------------------------------------------------------------------
-- module local variables and functions copied from Module:Wikidata

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

local function printDatavalueEntity(data, parameter)
	-- data fields: entity-type [string], numeric-id [int, Wikidata id]
	local id
	
	if data["entity-type"] == "item" then id = "Q" .. data["numeric-id"]
	elseif data["entity-type"] == "property" then id = "P" .. data["numeric-id"]
	else return printError("unknown-entity-type")
	end
	
	if parameter then
		if parameter == "link" then
			local linkTarget = mw.wikibase.sitelink(id)
			local linkName = mw.wikibase.label(id)
			if linkTarget then
				-- if there is a local Wikipedia article link to it using the label or the article title
				return "[[" .. linkTarget  .. "|" .. (linkName or linkTarget) .. "]]"
			else
				-- if there is no local Wikipedia article output the label or link to the Wikidata object to let the user input a proper label
				if linkName then return linkName else return "[[:d:" .. id .. "|" .. id .. "]]" end
			end
		else
			return data[parameter]
		end
	else
		return mw.wikibase.label(id) or id
	end
end

local function getSnakValue(snak, parameter)
	if snak.snaktype == "value" then
		-- call the respective snak parser
		if snak.datavalue.type == "string" then return snak.datavalue.value
		elseif snak.datavalue.type == "wikibase-entityid" then return printDatavalueEntity(snak.datavalue.value, parameter)
		end
	end
	return mw.wikibase.renderSnak(snak)
end
 
local 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
 
local 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

------------------------------------------------------------------------------
-- module local variables and functions derived from Module:Wikidata but customized

local function getValue(claims, sortindices, frame)
	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 showerrors = true
	
	local result
	local error
	if list then
		local value
		-- iterate over all elements and return their value (if existing)
		result = {}
		for idx in pairs(claims) do
			local claim = claims[sortindices[idx]]
			value, error =  getValueOfClaim(claim, qualifierId, parameter)
			if not value and showerrors then value = error end
			if value and references then value = value .. getReferences(frame, claim) end
			result[#result + 1] = value
		end
		result = table.concat(result, list)
	else
		-- return first element	
		local claim = claims[sortindices[1]]
		result, error = getValueOfClaim(claim, qualifierId, parameter)
		if result and references then result = result .. getReferences(frame, claim) end
	end
	return result
end

------------------------------------------------------------------------------
-- module export functions

local p = {}

function p.getPreferredOfficeholder(frame)
	local id = frame.args["id"]	-- "id" should be nil
	local showerrors = frame.args["showerrors"]
	local default = frame.args["default"]
	if default then showerrors = nil end
	local showerrors = true
	
	local entity = mw.wikibase.getEntity(id)
	local claims = entity['claims']['P1308']
	
	-- 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 = 2, normal = 1, preferred = 0 }
		local ranka = rankmap[claims[a].rank or "normal"]
		local rankb = rankmap[claims[b].rank or "normal"]
		return ranka < rankb
 	end
	table.sort(sortindices, comparator)
	
	result = getValue(claims, sortindices, frame)
 
	if result then return result else
		if showerrors then return error else return default end
	end
end

function p.getPreferredOfficeholderLink(frame)
	frame.args["parameter"] = "link"
	return p.getPreferredOfficeholder(frame)
end

function p.getPreferredOfficeholderStarttime(frame)
	frame.args["qualifier"] = "P580"
	return p.getPreferredOfficeholder(frame)
end

function p.getPreferredOfficeholderCountry(frame)
	frame.args["qualifier"] = "P17"
	return p.getPreferredOfficeholder(frame)
end

function p.getPreferredOfficeholderCountryLink(frame)
	frame.args["parameter"] = "link"
	return p.getPreferredOfficeholderCountry(frame)
end

return p

This module "OfficeData" is from Wikipedia if otherwise notified