Modul:WikidataIB: Perbedaan antara revisi

local i18n =

{

["ordinal"] =

{

},

["filespace"] = "File",

["latestdatequalifier"] = function (date) return "before " .. date end,

}

 

 

 

-- Private functions

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-- makeOrdinal needs to be internationalised along with the above:

return tostring(cardinal) .. ordsuffix

end

 

-------------------------------------------------------------------------------

-- 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 bc = string.upper(bc or "") -- can't use nil for bc

-- we only want to accept two possibilities: BC or default to BCE

bc = " " .. i18n["BCE"]

end

local postchrist = true -- start by assuming no BCE

local dateparts = {}

else

-- we'll keep the parts that are not 'BCE' in a table

end

end

if postchrist then bc = "" end -- set AD dates to no suffix **internationalise later**

local sep = " " -- separator is nbsp

local fdate = table.concat(dateparts, " ") -- formatted date defaults to same order as input

-- if we have day month year, check dateformat

if #dateparts == 3 then

fdate = dateparts[2]

end

return fdate .. bc

end

 

-------------------------------------------------------------------------------

-- allowing the parameter to be true or false by default.

local parseParam = function(param, default)

param = param:lower()

if (param == "false") or (param == "no") or (param == "0") then

end

end

 

-------------------------------------------------------------------------------

-- that an attacker might try to exploit.

-- It needs to be 'sanitised' by removing any wikitext before use.

end

end

 

-------------------------------------------------------------------------------

return refs > 0

end

 

-- parseInput processes the Q-id , the blacklist and the whitelist

local parseInput = function(frame, input_parm, property_id)

-- There may be a local parameter supplied, if it's blank, set it to nil

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

-- The blacklist is passed in named parameter |suppressfields

-- The whitelist is passed in named parameter |fetchwikidata

-- The name of the field that this function is called from is passed in named parameter |name

if blacklist then

-- The name is compulsory when blacklist is used, so return nil if it is not supplied

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

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]

return true, entity, props

end

return false, input_parm, nil

end

 

local function _getvalue(frame, entity, props, filter, propertyID)

-- if nothing or an empty string is passed set it true

-- if "false" or "no" or "0" is passed set it false

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

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

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

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

separator = string.gsub(separator, '"', '')

if #separator == 0 then

separator = sepdefault

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

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

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

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

lpostfix = string.gsub(lpostfix, '"', '')

-- So now we have something to return: deal with:

-- (1) ["datatype"] = "wikibase-item";

-- ["datatype"] = "url"

-- (4) ["datatype"] = "globe-coordinate", or anything else

local lang = mw.language.getContentLanguage().code

local thisQid = entity.id

local datavalue = v.mainsnak.datavalue

datavalue = datavalue and datavalue.value

-- do nothing; either isn't preferred when prefered values are requested, or isn't sourced when onlysourced=true

elseif v.mainsnak.snaktype == "somevalue" then -- check for value is unknown

local label = labelOrId(qnumber)

if sitelink then

else

-- no sitelink, so check first for a redirect with that label

-- no sitelink, but there's a redirect with the same title as the label

-- let's link to that

else

-- no sitelink and not a redirect but an article exists with the same title as the label

if dateprecision >= 10 then -- prepend month

fpvdate = i18n.months[tonumber(timestamp:sub(7, 8))] .. " " .. fpvdate

if dateprecision >= 11 then -- prepend day

fpvdate = tonumber(timestamp:sub(10, 11)) .. " " .. fpvdate

end

end

elseif dateprecision == 7 then -- century

local century = math.floor((fpvdate - 1) / 100) + 1

fdate = makeOrdinal(century) .. " " .. i18n["century"]

if timestamp:sub(1, 1) == "-" then -- date is BC

-- we only want to accept two possibilities: BC or default to BCE

if bc == "BC" then

-- commonsMedia or external-id or string or url

-- all have mainsnak.datavalue.value as string

out[#out+1] = "[[" .. lprefix .. datavalue .. lpostfix .. "|" .. prefix .. datavalue .. postfix .. "]]"

else

-- the unit is of the form http://www.wikidata.org/entity/Q829073

-- convert amount to a number

local amount = tonumber(datavalue.amount) or "Not a number"

local upb = tonumber(datavalue.upperBound)

local lowb = tonumber(datavalue.lowerBound)

end

-- extract the qid in the form 'Qnnn' from the value.unit url and then fetch the label from that

local unitqid = string.match( datavalue.unit, "(Q%d+)" )

if unitqid then

end

else

-- some other data type

break

end -- of datatype/unknown value/sourced check

end -- of for each value loop

-- if there's anything to return, then return a list

-- comma-separated by default, but may be specified by the sep parameter

if #out > 0 then

if sorted then table.sort(out) end

else

end

else

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

local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)

if not success then

return errorOrEntity

end

local function filter(claim)

return true

end

end

-------------------------------------------------------------------------------

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

p.getPreferredValue = function(frame)

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

local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)

if not success then

return errorOrEntity

end

local prefflag = false

for k, v in pairs(props) do

break

end

return claim.rank == "preferred" or prefflag == false

end

end

 

-------------------------------------------------------------------------------

--

 

 

-------------------------------------------------------------------------------

p.getCoords = function(frame)

local propertyID = "P625"

-- if there is a 'display' parameter supplied, use it

-- otherwise default to "inline, title"

local disp = frame.args.display

disp = "inline, title"

end

if not success then

return errorOrEntity

-- read the latitude numbers into a table

for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do

end

-- add the N/S

-------------------------------------------------------------------------------

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

-- The boolean onlysourced= parameter can be set to return nothing

-- when the property is unsourced (or only sourced to Wikipedia)

p.getQualifierValue = function(frame)

 

-- The PropertyID of the target value of the property

-- whose qualifier is to be returned is passed in named parameter |pval=

-- The PropertyID of the qualifier

-- whose value is to be returned is passed in named parameter |qual=

 

-- onlysourced is a boolean passed to return qualifiers

-- if nothing or an empty string is passed set it false

-- if "false" or "no" or 0 is passed set it false

if not success then

return errorOrEntity

return nil

end

 

-------------------------------------------------------------------------------

if itemID == "" then return end

return mw.wikibase.sitelink(itemID)

end

 

return format_Date(frame.args[1], frame.args.df, frame.args.bc)

end

 

-------------------------------------------------------------------------------

end

 

 

return p