Modul:WikidataIB: Perbedaan antara revisi

-- Module to implement use of a blacklist and whitelist for infobox fields

-- Can take a named parameter |qid which is the Wikidata ID for the article

 

local cdate -- initialise as nil and only load _complex_date function if needed

-- The following, taken from https://www.mediawiki.org/wiki/Wikibase/DataModel#Dates_and_times,

-- is needed to use Module:Complex date which seemingly requires date precision as a string.

["errors"] =

{

["qualifier-not-found"] = "Qualifier not found.",

["dab-page"] = " (dab)",

},

["months"] =

{

},

["ordinal"] =

{

},

["filespace"] = "File",

["Unknown"] = "Unknown",

-- set the following to the name of a tracking category,

-- e.g. "[[Category:Articles with missing Wikidata information]]", or "" to disable:

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

-- some languages, e.g. Bosnian use a period as a suffix after each number in a date

["multipliers"] = {

[0] = "",

}

}

if 'en' ~= mw.getContentLanguage():getCode() then

require("Module:i18n").loadI18n("Module:WikidataIB/i18n", i18n)

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

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

-- we need three exceptions in English for 1st, 2nd, 3rd, 21st, .. 31st, etc.

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

-- dateFormat is the handler for properties that are of type "time"

-- It takes timestamp, precision (6 to 11 per mediawiki), dateformat (y/dmy/mdy), BC format (BC/BCE),

-- any qualifiers for the property, the language, and any adjective to use like 'before'.

-- It passes the date through the "complex date" function

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

local dateFormat = function(timestamp, dprec, df, bcf, pd, qualifiers, lang, adj, model)

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

-- So fix the month 0, day 0 timestamp to become 1 January instead:

timestamp = timestamp:gsub("%-00%-00T", "-01-01T")

-- just in case date precision is missing

dprec = dprec or 11

-- no point in saying that dates before 1582 are Julian - they are by default

-- doesn't make sense for dates less precise than year

local calendarmodel = ""

if tonumber(year) > 1582

-- it makes the empty string and nil into the (boolean) value passed as default

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

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

-- Dependencies: none

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

local parseParam = function(param, default)

if param and param ~= "" then

param = param:lower()

local sitelink

if wiki == "" then

else

end

return sitelink

label = mw.wikibase.getLabelByLang(id, lang)

else

end

if label then

-- shortname is boolean switch to use P1813 (short name) instead of label if true.

-- lang is the current language code.

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

-- Dependencies: labelOrId(); donotlink[]

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

-- see if item might need italics or quotes

local fmt = ""

end

end

local disp

local label, islabel

if dtxt then

if sitelink then

if not (dtxt or shortname) then

end

end

end

elseif islabel then

end -- test if article title exists as redirect on current Wiki

else

-- no sitelink and no label, so return whatever was returned from labelOrId for now

-- add tracking category [[Category:Articles with missing Wikidata information]]

end

else

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

-- sourced takes a table representing a statement that may or may not have references

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

-- Dependencies: none

for kr, vr in pairs(claim.references) do

local ref = mw.wikibase.renderSnaks(vr.snaks)

return true

end

input_parm = mw.text.trim(input_parm or "")

if input_parm == "" then input_parm = nil end

 

local args = frame.args

 

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

local fieldname = args.name or ""

 

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

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

-- createicon assembles the "Edit at Wikidata" pen icon.

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

-- Dependencies: i18n[];

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

local createicon = function(langcode, entityID, propertyID)

return icon

end

-- assembleoutput takes the sequence table containing the property values

-- and formats it according to switches given. It returns a string or nil.

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

-- Dependencies: parseParam();

-- Zero or not a number result in no collapsing (default becomes 0).

local collapse = tonumber(args.collapse) or 0

 

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

if #out > 0 then

if sorted then table.sort(out) end

out[#out] = out[#out] .. createicon(args.langobj.code, entityID, propertyID)

end

strout = nil -- no items had valid reference

end

return strout

end

local qnumber = dv.id

if linked then

else -- no link wanted so check for display-text, otherwise test for lang code

local label, islabel

if uabbr then

-- see if there's a unit symbol (P5061)

local fbtbl = mw.language.getFallbacksFor( args.lang )

table.insert( fbtbl, 1, args.lang )

local found = false

for idx1, us in ipairs(unitsymbols) do

args.pd = pd

 

 

-- all proper values of a Wikidata property will be the same type as the first

-- qualifiers don't have a mainsnak, properties do

local datatype = objproperty[1].datatype or objproperty[1].mainsnak.datatype

-- mlt[] holds the language code if the datatype is monolingual text

local out = {}

local mlt = {}

for k, v in ipairs(objproperty) do

local hasvalue = true

-- See if qualifiers are to be returned:

local snak = v.mainsnak or v

local qlist = {}

-- *** internationalise date separators later ***

local dsep = "–"

if t:find("%s") or t:find(" ") then dsep = " – " end

if qualsonly then

out[#out+1] = qstr

out[#out] = out[#out] .. " (" .. qstr .. ")"

end

if qualsonly then

else

end

end

local uabbr = parseParam(args.unitabbr or args.uabbr, false)

local filter = (args.unit or ""):upper()

if filter == "" then filter = nil end

 

return nil

end -- of check for string

end -- of loop through values of propertyID

return assembleoutput(out, frame.args, qid, propertyID)

end

for i2, v2 in ipairs(proptbl) do

if parttbl then

-- this higher location has qualifier 'applies to part' (P518)

end

 

local inst = mw.wikibase.getAllStatements(qid, "P31")

if #inst > 0 then

for k, v in ipairs(inst) do

-- stop if it's a country (or a country within the United Kingdom if skip is true)

prop = nil -- this will ensure this is treated as top-level location

break

if prop and prop.mainsnak.datavalue then

if not skip or count == 0 then

end

qid, prevqid = prop.mainsnak.datavalue.value.id, qid

until finished or count >= 10 -- limit to 10 levels to avoid infinite loops

 

if not first then table.remove(out, 1) end

 

 

args.reqranks = setRanks(args.rank)

 

local f = {}

-- getCoords is used to get coordinates for display in an infobox

-- whitelist and blacklist are implemented

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

-- Dependencies: setRanks(); parseInput(); decimalPrecision();

 

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

local disp = frame.args.display or ""

if disp == "" then

end

 

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

for k1, v1 in pairs(props) do

if v1.mainsnak.snaktype == "value" and v1.mainsnak.datavalue.type == "wikibase-entityid" then

if v1.mainsnak.datavalue.value.id == propvalue and v1.qualifiers then

if onlysrc == false or sourced(v1) then

-- if we've got this far, we have a (sourced) claim with qualifiers

end

end

return props -- no property or local parameter supplied

end -- of test for success

end

 

-- Dependencies: parseParam; setRanks; parseInput; sourced; propertyvalueandquals assembleoutput;

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

local pid1 = args.prop1 or args.pid1 or ""

local pid2 = args.prop2 or args.pid2 or ""

if pid1 == "" or pid2 == "" then return nil end

local onlysrc = parseParam(args.onlysourced or args.osd, true)

local maxvals = tonumber(args.maxvals) or 0

end -- of loop through values of property1

return assembleoutput(out, args, qid1, pid1)

end

 

local p734 = mw.wikibase.getBestStatements(qid1, "P734")[1]

local p734id = p734 and p734.mainsnak.snaktype == "value" and p734.mainsnak.datavalue.value.id or ""

-- strip namespace and disambigation

local pos = famname:find(":") or 0

famname = famname:sub(pos+1):gsub("%s%(.+%)$", "")

if famname == "" then

famname = lbl and mw.text.nowiki(lbl) or ""

end

if statements2[1] and statements2[1].mainsnak.snaktype == "value" then

local qid3 = statements2[1].mainsnak.datavalue.value.id

-- if there's no local sitelink, create the sitelink from English label

if not sitelink then

local p734 = mw.wikibase.getBestStatements(qid, "P734")[1]

local p734id = p734 and p734.mainsnak.snaktype == "value" and p734.mainsnak.datavalue.value.id or ""

-- strip namespace and disambigation

local pos = famname:find(":") or 0

famname = famname:sub(pos+1):gsub("%s%(.+%)$", "")

if famname == "" then

famname = lbl and mw.text.nowiki(lbl) or ""

end

local tmcID = p910.mainsnak.datavalue.value.id

-- use sitelink or the English label for the cat

if not cat then

local lbl = mw.wikibase.getLabelByLang(tmcID, "en")

if maxvals > 0 and #cat2 >= maxvals then break end

end

for k1, v1 in ipairs(cat1) do

for k2, v2 in ipairs(cat2) do

qtype = vqualifiers[v1][1].datatype

if qtype == "time" then

elseif qtype == "url" then

end

else

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

if itemID == "" then return end

local label = labelOrId(itemID)

if sitelink then

local label = labelOrId(itemID, lang)

return label

end

 

-- has the qid of a Wikidata entity passed as the first unnamed parameter or as |qid=

-- If there is a sitelink to an article on the local Wiki, it returns the sitelink as plain text.

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

-- Dependencies: none

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

if itemID == "" then return end

end

 

if itemID == "" then itemID = nil end

if desc:lower() == 'wikidata' then

elseif desc:lower() == 'none' then

return nil

if not (whitelist == 'ALL' or whitelist:find(fieldname)) then return nil end

 

 

if not aliases then return nil end

 

args.langobj = findLang(args.lang)

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

p.labelorid = function(frame)

end

 

 

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

-- If qid is not given, it uses the qid for the connected page

-- or returns nil if there isn't one.

-- If props is given, the Wikidata item for the qid is examined for each property in turn.

-- If that property contains a value that is another Wikibase-item, that item's qid is returned,

-- If props is not given, the qid is returned.

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

-- Dependencies: parseParam()

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

if qid == "" then

qid = mw.wikibase.getEntityIdForCurrentPage()

if not qid then return nil end

local out = {}

if props ~= "" then

for p in mw.text.gsplit(props, "%p") do -- split at punctuation and iterate

end

if #out > 0 then

else

return qid

end

end

 

if pid == "" then pid = par[1] end

if qid == "" then qid = par[2] end

if pid:sub(1,1) ~= "P" then return "No property supplied" end

if not qid then return "No item for this page" end

return "<pre>" .. mw.dumpObject( mw.wikibase.getAllStatements( qid, pid ) ) .. "</pre>"

-- from the item given by the parameter 'qid'

-- or from the Wikidata item associated with the current page if qid is not supplied.

-- If property is not supplied, then P31 (instance of) is assumed.

-- It returns val if found or nothing if not found.

if qid:sub(1,1) ~= "Q" then qid = mw.wikibase.getEntityIdForCurrentPage() end

if not qid then return nil end

if not stats[1] then return nil end

if stats[1].mainsnak.datatype == "wikibase-item" then

for k, v in pairs( stats ) do

return val

end

-- but it keeps the "edit at Wikidata" pen icon out of the microformat.

-- Usually it will take its url parameter directly from a Wikidata call:

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

-- Dependencies: none

local txt = frame.args.url or ""

if txt == "" then return nil end

local url, icon = txt:match("(.+)&nbsp;(.+)")

icon = icon or ""

return '<span class="url">[' .. prot .. addr .. " " .. disp .. "]</span>&nbsp;" .. icon

end

local args = frame.args or frame:getParent().args or {}

 

 

if not labels then return i18n["labels-not-found"] end

 

local args = frame.args or frame:getParent().args or {}

 

 

if not descriptions then return i18n["descriptions-not-found"] end

 

local args = frame.args or frame:getParent().args or {}

 

 

if not aliases then return i18n["aliases-not-found"] end

 

local site = args.site or ""

local showdab = parseParam(args.showdab, true)

if qid then

local prop31 = mw.wikibase.getBestStatements(qid, "P31")[1]

end

end

end

 

getValueByLang

getValueByRefSource

getPropOfProp

getAwardCat

getLink

getLabel

getAT

getDescription

getQID

followQid

siteID

projID

checkValidity

getEntityFromTitle

--]]

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