Módulo:Testes

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa
Documentação do módulo[ver] [editar] [histórico] [purgar]

Esta é uma página de teste de módulos. Altere livremente o conteúdo dessa página para fazer seus testes.

Quando terminar, se possível, retorne para o conteúdo original, pois pode servir de exemplo para outros usuários.

Execução 1[editar código-fonte]

{{#invoke:testes|ola}}Erro de comando: A função "ola" não existe.

Execução 2[editar código-fonte]

{{#invoke:testes|retorna|aqui}}Erro de comando: A função "retorna" não existe.

Execução 3[editar código-fonte]

{{#invoke:testes|parametros|param1|nome=param3|param4=param4|param2}}Erro de comando: A função "parametros" não existe.

Execução 4[editar código-fonte]

{{#invoke:testes|procura|Rosas são vermelhas.|vermelhas}}Erro de comando: A função "procura" não existe.

Execução 5[editar código-fonte]

{{#invoke:testes|substitui|Rosas são vermelhas.|Rosas|Laranjas}}Erro de comando: A função "substitui" não existe.

Execução 6[editar código-fonte]

{{#invoke:testes|regex|AAaaAaa BBbbBbb|([Aa]+) ([Bb]+)|%2 %1}}Erro de comando: A função "regex" não existe.

Execução 7[editar código-fonte]

{{#invoke:testes|tamanho|Rosas são vermelhas.}}Erro de comando: A função "tamanho" não existe.

-- Página liberada, edite a vontade :)
 
-- Comentário de linha
--[[
	Comentário de várias
	linhas
]]--
-- 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 do artigo 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"] = "Artigo ainda não se econtra 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 = "&nbsp;" .. i18n["ac"] -- prepend the space. **internationalise later**
    else
        bc = "&nbsp;" .. 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 = "&nbsp;de&nbsp;" -- separator is nbsp+de+nbsp
    local fdate = table.concat(dateparts, "&nbsp;de&nbsp;") -- 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 or frame.args.wikidata
    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 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
                                out[#out + 1] = "[[" .. sitelink .. "|" .. label .. "]]" -- devolve o link pro artigo com um rótulo label
                            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 .. "]]&nbsp;<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.."&nbsp;"..i18n["ac"])
                            else
                                fdate = mw.ustring.gsub(i18n["decade"], "$1", decade.."&nbsp;"..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.."&nbsp;"..i18n["ac"])
                            else
                                fdate = mw.ustring.gsub(i18n["century"], "$1", century.."&nbsp;"..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
       
    -- 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 .. "]]&nbsp;<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


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

-------------------------------------------------------------------------------
-- 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] or result1[2] or result1[3] or result2[1] or result2[2] or result2[3] ) == "Desconhecido" then
        return "Desconhecido"
    end
   
    return frame:expandTemplate{ title = 'Morte', args = {result1[1],result1[2],result1[3],result2[1],result2[2],result2[3],lang = idioma}}
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] or result[2] or result[3]) == "Desconhecido" then
        return "Desconhecido"
    end
   
    if result[3] ~= "" and result[3] ~= nil then -- proteger comparação
        if tonumber(result[3])<1900 then
        comidade = "si" -- si
        end
    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


return p