Modul:WikidataIB: Perbedaan antara revisi

local p = {}

 

-- Module:I18n/complex date, Module:ISOdate, Module:DateI18n (alternative for Module:Date),

-- Module:Formatnum, Module:I18n/date, Module:Yesno, Module:Linguistic, Module:Calendar

["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 nolinks_exists then

donotlink = nolinks.itemsindex

end

 

end

return langobj

end

 

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

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

local _getSitelink = function(qid, wiki)

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

wiki = wiki or ""

local 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

postfix = postfix or ""

lang = lang or "en" -- fallback to default if missing

local disp

local sitelink = mw.wikibase.sitelink(id)

if sitelink then

if not (dtxt or shortname) then

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

end

if donotlink[label] then

else

end

elseif islabel then

if artitle and artitle.redirectTarget and not donotlink[label] then

-- there's a redirect with the same title as the label, so let's link to that

else

-- no sitelink, label exists, not redirect (or donotlink) so output plain label

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

else

local createicon = function(langcode, entityID, propertyID)

local icon = "&nbsp;[[" .. i18n["filespace"]

icon = icon .. i18n["editonwikidata"]

icon = icon .. "|link=https://www.wikidata.org/wiki/" .. entityID

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

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

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

hasvalue = false

else

end

 

-- See if qualifiers are to be returned:

local snak = v.mainsnak or v

local qsep = (args.qsep or ""):gsub('"', '')

local qargs = {

["unitabbr"] = tostring(uabbr),

["maxvals"] = 0,

["noicon"] = "true",

["list"] = args.qlist,

["langobj"] = args.langobj,

["lang"] = args.langobj.code,

}

local qlist = {}

local ts = v.qualifiers[v1][1].datavalue.value.time

local dp = v.qualifiers[v1][1].datavalue.value.precision

else

end

end

else

local ql = propertyvalueandquals(v.qualifiers, qargs)

for k1, v1 in ipairs(ql) do

qlist[#qlist + 1] = v1

end

local ts = v1[1].datavalue.value.time

local dp = v1[1].datavalue.value.precision

end

end

-- otherwise look through the fallback languages for a match

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

local bestval = ""

local found = false

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

 

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

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

-- check if it's an instance of (P31) a country (Q6256) and terminate the chain if it is

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

end

end

if prop and prop.mainsnak.datavalue then

if not skip or count == 0 then

out[#out+1] = linkedItem(qid, ":", "", "", "") -- get a linked value if we can

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

 

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

 

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

 

-- set the requested ranks flags

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)

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

return label

end

 

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

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

-- If there is no sitelink, it returns nothing.

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

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

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

p.followQid = function(frame)

local qid = (frame.args.qid or ""):upper()

if qid == "" then

qid = mw.wikibase.getEntityIdForCurrentPage()

end

if not qid then return nil end

local props = (frame.args.props or ""):upper()

if props ~= "" then

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

 

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

 

 

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

else

return false

end

end

-- List of exported functions

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

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