Módulo:OfficeData

Documentação do módulo[ver] [editar] [histórico] [purgar]

Descrição

Este Módulo implementa a predefinição {{Wikidata}}. Por favor consulte a predefinição para mais instruções.

Uso

Outra documentação:

• Wikipédia:Lua
• en:Module talk:Wikidata

------------------------------------------------------------------------------
-- 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