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 p = {}

 

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

["local-article-not-found"] = "Article is available on Wikidata, but not on Wikipedia",

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

if nolinks_exists then

donotlink = nolinks.itemsindex

end

 

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

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

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

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

end

return langobj

end

 

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

-- Dependencies: findLang(); cdate(); dp[]

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

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

end

end

-- this may have QuickStatements info appended to it in a div, so remove that

fdate = fdate:gsub(' <div style="display: none;">[^<]*</div>', '')

-- it may also be returned wrapped in a microformat, so remove that

fdate = fdate:gsub("<[^>]*>", "")

-- if 'circa', use the abbreviated form *** internationalise later ***

fdate = fdate:gsub('circa ', '<abbr title="circa">c.</abbr>&nbsp;')

-- 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 _getSitelink = function(qid, wiki)

qid = (qid or ""):upper()

wiki = wiki or ""

local sitelink

if wiki == "" then

else

end

return sitelink

-- _getCommonslink takes an optional qid of a Wikidata entity passed as |qid=

-- It returns one of the following in order of preference:

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

-- Dependencies: _getSitelink(); parseParam()

if not qid then return nil end

onlycat = parseParam(onlycat, false)

local sitelink = _getSitelink(qid, "commonswiki")

if onlycat and sitelink and sitelink:sub(1,9) ~= "Category:" then sitelink = nil end

local prop910 = mw.wikibase.getBestStatements(qid, "P910")[1]

if prop910 then

sitelink = _getSitelink(tmcid, "commonswiki")

end

end

local prop373 = mw.wikibase.getBestStatements(qid, "P373")[1]

if prop373 then

if sitelink then sitelink = "Category:" .. sitelink end

end

-- Dependencies: none

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

if label then

return mw.text.nowiki(label), true

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

-- lang is the current language code.

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

-- Dependencies: labelOrId(); donotlink[]

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

local disp

local label, islabel

if dtxt then

if sitelink then

if not (dtxt or shortname) then

end

if donotlink[label] then

else

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

pre = pre or ""

post = post or ""

-- allow values to display a fixed text instead of label

local dtxt = args.displaytext or args.dt

if dtxt == "" then dtxt = nil end

-- switch to use display of short name (P1813) instead of label

local snak = propval.mainsnak or propval

local dv = snak.datavalue

dv = dv and dv.value

-- value and monolingual text language code returned

local qnumber = dv.id

if linked then

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

local label, islabel

-- qualifiers (if any) is a nested table or nil

-- lang is given, or user language, or site language

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

-- data types which are strings:

-- don't link if no linkpre/postfix or linkprefix is just ":"

val = pre .. dv .. post

else

val = "[[" .. lpre .. dv .. lpost .. "|" .. pre .. dv .. post .. "]]"

-- if we have conversions, we won't have formatted numbers or scales

if conv then

fnum = false

args.scale = "0"

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

end

-- format display:

if range == "" then

else

end

elseif unit == "$" or unit == "£" then

-- default is deg/min/sec -- decimal degrees needs |format = dec

local form = (args.format or ""):lower():sub(1,3)

--

local show = (args.show or ""):lower()

if show ~= "longlat" then show = show:sub(1,3) end

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

local out = {}

local mlt = {}

for k, v in ipairs(objproperty) do

local hasvalue = true

-- no value: it isn't sourced when onlysourced=true

hasvalue = false

else

end

 

-- See if qualifiers are to be returned:

local snak = v.mainsnak or v

local qlist = {}

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

local dsep = "&ndash;"

if t:find("%s") or t:find("&nbsp;") then dsep = " &ndash; " end

if qualsonly then

out[#out+1] = qstr

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

end

if qualsonly then

else

end

end

-- otherwise look through the fallback languages for a match

if datatype == "monolingualtext" and #out >1 then

local bestval = ""

local found = false

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

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

if filter == "" then filter = nil end

 

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

-- so see if matches the required value

if v1q[qualID][1].datatype == "wikibase-item" then

if checkvalue(v1q[qualID][1].datavalue.value.id) then

out[#out + 1] = rendersnak(v1, args, linked, lpre, lpost, pre, post, uabbr, filter)

end

return nil

end -- of check for string

end -- of loop through values of propertyID

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

 

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

-- from the initial item to higher level territories/locations until it reaches the highest.

-- An optional boolean, 'first', determines whether the first item is returned (default: false).

first = parseParam(first, false)

skip = parseParam(skip, false)

local out = {}

local langcode = findLang():getCode()

local finished = false

local count = 0

repeat

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

end

end

if prop and prop.mainsnak.datavalue then

if not skip or count == 0 then

end

else

-- Use full label if there's no short name or this is the first item

local prop1813 = mw.wikibase.getAllStatements(qid, "P1813")

count = count + 1

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

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

-- we might have duplicate text for consecutive locations, so remove them

if #out > 2 then

end

return out

end

 

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

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

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

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

-- labelOrId; i18n.latestdatequalifier; format_Date; makeOrdinal; roundto; decimalPrecision; decimalToDMS;

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

-- parameter sets for commonly used groups of parameters

if paraset == 1 then

elseif paraset == 2 then

end

 

 

 

 

if not entityid then

return props -- either the input parameter or nothing

end

-- qual is a string containing the property ID of the qualifier(s) to be returned

-- if qual == "ALL" then all qualifiers returned

-- if qual == "DATES" then qualifiers P580 (start time) and P582 (end time) returned

-- if nothing or an empty string is passed set it nil -> no qualifiers returned

if qualID == "" then qualID = nil end

 

 

-- table 'out' stores the return value(s):

 

-- format the table of values and return it as a string:

end

 

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

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

 

frame.args.langobj = findLang(frame.args.lang)

 

-- set the requested ranks flags

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

end -- of test for success

return nil

end

 

-- a property ID (the unnamed parameter or 1=Pxxx)

-- the ID of a qualifier for that property (qualID=Pyyy)

-- The usual whitelisting, blacklisting, onlysourced, etc. are implemented

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

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

p.getValueByLang = function(frame)

-- The language code for the qualifier we want to match is in named parameter |lang=

local function checkLanguage(id)

-- id should represent a language like "British English (Q7979)"

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

-- getValueByRefSource gets the value of a property which has a reference "stated in" (P248)

-- The call needs:

-- a property ID (the unnamed parameter or 1=Pxxx)

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

args.noicon = "true"

return assembleoutput(out, args, qid, pid1)

end

 

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 itemID = mw.text.trim(frame.args[1] or frame.args.qid or "")

if itemID == "" then return end

return label

end

 

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

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

-- optional boolean parameter first toggles the display of the first item

-- optional boolean parameter skip toggles the display to skip to the last item

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

-- Dependencies: _location();

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

p.location = function(frame)

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

local first = mw.text.trim(frame.args.first or "")

local skip = mw.text.trim(frame.args.skip or "")

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

p.labelorid = function(frame)

end

 

end

return langcode

end

 

-- getQid returns the qid, if supplied

-- failing that, the Wikidata entity ID of the "category's main topic (P301)", if it exists

-- otherwise, nothing

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

 

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

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

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

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

if qid == "" then

qid = mw.wikibase.getEntityIdForCurrentPage()

end

if not qid then return nil end

if props ~= "" then

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

local linkedid = v.mainsnak.datavalue and v.mainsnak.datavalue.value.id

if linkedid then

end -- loop through values of property to follow

end -- loop through list of properties to follow

end

 

end

 

return lang:formatNum( num )

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

 

 

 

-- that is, something like Q1235 or P123.

-- It returns the strings "true" or "false".

-- Change false to nil to return "true" or "" (easier to test with #if:).

function p.checkValidity(frame)

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

return false

end

end

 

-- List of exported functions

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

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