Modul:WikidataIB/sandbox: 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

-- whitelist is passed in named parameter |fetchwikidata (or |fwd)

 

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.

}

}

 

-- This piece of html implements a collapsible container. Check the classes exist on your wiki.

local collapsediv = '<div class="mw-collapsible mw-collapsed" style="width:100%; overflow:auto;" data-expandtext="{{int:show}}" data-collapsetext="{{int:hide}}">'

 

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

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

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

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

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

 

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

-- otherwise it tries to create it from the user's set language ({{int:lang}})

-- failing that it uses the wiki's content language.

langobj = mw.language.new( langcode )

else

if mw.language.isKnownLanguageTag(langcode) then

langobj = mw.language.new( langcode )

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

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

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

if qid == "" then qid = mw.wikibase.getEntityIdForCurrentPage() end

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

-- check for Commons category (string value)

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

-- 4. Display unlinked label if it exists

-- 5. Display entity-id for now to indicate a label could be provided

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

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

local disp

if mw.site.siteName ~= "Wikimedia Commons" then

if sitelink then

else

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

local ccat = mw.wikibase.getBestStatements(id, "P373")[1]

ccat = ccat.mainsnak.datavalue.value

disp = "[[" .. lprefix .. "Category:" .. ccat .. lpostfix .. "|" .. prefix .. label .. postfix .. "]]"

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

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

-- If a non-blank input parameter was supplied return it

if input_parm then return false, input_parm end

 

-- Otherwise see if this field is on the whitelist:

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

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

-- monolingualtext

-- It also requires linked, the link/pre/postfixes, uabbr, and the arguments passed from frame.

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

-- Dependencies: parseParam(); labelOrId(); i18n[]; dateFormat();

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

local rendersnak = function(propval, args, linked, lpre, lpost, pre, post, uabbr, filter)

pre = pre or ""

post = post or ""

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

end

val = pre .. label .. post

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

end

--

-- convert amount to a number

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

if filter and unitqid ~= filter then return nil end

local uname = mw.wikibase.getLabelByLang(unitqid, args.lang) or ""

if uname ~= "" then usep, unit = " ", uname end

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

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

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

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

frame.args.lang = frame.args.langobj.code

 

-- check for locally supplied parameter in second unnamed parameter

-- success means no local parameter and the property exists

 

if qid then

-- with a qualifier like "language of work or name (P407)" in qualID

-- whose value has the required ID, like "British English (Q7979)", in qval

local v1q = v1.qualifiers

if v1q and v1q[qualID] then

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

end

end

end -- of check for matching required value and has qualifiers

else

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

return out

end

 

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

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

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

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

local out = {}

local mlt= {}

if onlysrc == false or sourced(v1) then

if v1.references then

if v2.snaks.P248 then

if v3.datavalue.value.id == qval then

out[#out+1], mlt[#out+1] = rendersnak(v1, frame.args, linked, "", "", "", "", uabbr, unit)

return props -- no property or local parameter supplied

end -- of test for success

end

 

-- the Commons sitelink of the topic's main category of the linked Wikidata item;

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

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

p.getCommonsLink = function(frame)

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

 

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

p.siteID = function(frame)

-- This deals with specific exceptions: be-tarask -> be-x-old

if txtlang == "be-tarask" then

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

p.projID = function(frame)

-- This deals with specific exceptions: be-tarask -> be-x-old

if txtlang == "be-tarask" then

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

end

 

-- 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 url = frame.args.url or ""

if url:upper() == "NONE" then return nil end

local urls = {}

local quals = {}

local prop856 = mw.wikibase.getBestStatements(qid, "P856")

for k, v in pairs(prop856) do

end -- test for website having a value

end -- loop through website(s)

end

if #urls == 0 then return nil 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

 

 

return table.concat(out, "; ")

end

 

-- List of exported functions

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

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