Modul:WikidataIB: Perbedaan antara revisi

Konten dihapus Konten ditambahkan
k Melindungi "Modul:WikidataIB": 7. Templat atau modul yang banyak digunakan ([Sunting=Hanya untuk pengurus] (selamanya) [Pindahkan=Hanya untuk pengurus] (selamanya))
Farras (bicara | kontrib)
k update
Baris 12:
local p = {}
 
local cdate =-- require("Module:Complexinitialise as nil and only load date")._complex_date function if needed
-- [[Module:Complex date]] is loaded lazily and has the following dependencies:
-- Module:I18n/complex date, Module:ISOdate, Module:DateI18n (alternative for Module:Date),
-- Module:Formatnum, Module:I18n/date, Module:Yesno, Module:Linguistic, Module:Calendar
Baris 32:
["errors"] =
{
["property-not-found"] = "PropertiProperty tidaknot ditemukanfound.",
["No property supplied"] = "TidakNo adaproperty properti yang disediakansupplied",
["entity-not-found"] = "Butir Wikidata tidakentity not ditemukanfound.",
["unknown-claim-type"] = "JenisUnknown klaimclaim yang tidak diketahuitype.",
["unknown-entity-type"] = "JenisUnknown butirentity yang tidak diketahuitype.",
["qualifier-not-found"] = "Qualifier not found.",
["site-not-found"] = "Proyek Wikimedia tidakproject not ditemukanfound.",
["labels-not-found"] = "TidakNo adalabels label yang ditemukanfound.",
["descriptions-not-found"] = "TidakNo adadescriptions deskripsi yang ditemukanfound.",
["aliases-not-found"] = "TidakNo adaaliases alias yang ditemukanfound.",
["unknown-datetime-format"] = "FormatUnknown datetime yang tidak diketahuiformat.",
["local-article-not-found"] = "Article is available on Wikidata, but not on Wikipedia",
["dab-page"] = " (dab)",
Baris 48:
["months"] =
{
"JanuariJanuary", "FebruariFebruary", "MaretMarch", "April", "MeiMay", "JuniJune",
"JuliJuly", "AgustusAugust", "September", "OktoberOctober", "November", "DesemberDecember"
},
["century"] = "abadcentury",
["BC"] = "SMBC",
["BCE"] = "SMBCE",
["ordinal"] =
{
[1] = "st",
[2] = "nd",
[3] = "rd",
["default"] = "th"
},
["filespace"] = "File",
["Unknown"] = "Unknown",
["NaN"] = "BukanNot sebuaha angkanumber",
-- set the following to the name of a tracking category,
-- e.g. "[[Category:Articles with missing Wikidata information]]", or "" to disable:
["missinginfocat"] = "[[KategoriCategory:ArtikelArticles tanpawith informasimissing Wikidata information]]",
["editonwikidata"] = "SuntingEdit inithis dion Wikidata",
["latestdatequalifier"] = function (date) return "before " .. date end,
-- some languages, e.g. Bosnian use a period as a suffix after each number in a date
Baris 74:
["multipliers"] = {
[0] = "",
[3] = " ributhousand",
[6] = " jutamillion",
[9] = " miliarbillion",
[12] = " triliuntrillion",
}
}
Baris 95:
if nolinks_exists then
donotlink = nolinks.itemsindex
end
 
-- To satisfy Wikipedia:Manual of Style/Titles, certain types of items are italicised, and others are quoted.
-- The submodule [[Module:WikidataIB/titleformats]] lists the entity-ids used in 'instance of' (P31),
-- which allows this module to identify the values that should be formatted.
-- WikidataIB/titleformats exports a table p.formats, which is indexed by entity-id, and contains the value " or ''
local formats = {}
local titleformats_exists, titleformats = pcall(mw.loadData, "Module:WikidataIB/titleformats")
if titleformats_exists then
formats = titleformats.formats
end
 
Baris 148 ⟶ 158:
end
return langobj
end
 
 
-------------------------------------------------------------------------------
-- _getItemLangCode takes a qid parameter (using the current page's qid if blank)
-- If the item for that qid has property country (P17) it looks at the first preferred value
-- If the country has an official language (P37), it looks at the first preferred value
-- If that official language has a language code (P424), it returns the first preferred value
-- Otherwise it returns nothing.
-------------------------------------------------------------------------------
-- Dependencies: none
-------------------------------------------------------------------------------
local _getItemLangCode = function(qid)
qid = mw.text.trim(qid or ""):upper()
if qid == "" then qid = mw.wikibase.getEntityIdForCurrentPage() end
if not qid then return end
local prop17 = mw.wikibase.getBestStatements(qid, "P17")[1]
if not prop17 or prop17.mainsnak.snaktype ~= "value" then return end
local qid17 = prop17.mainsnak.datavalue.value.id
local prop37 = mw.wikibase.getBestStatements(qid17, "P37")[1]
if not prop37 or prop37.mainsnak.snaktype ~= "value" then return end
local qid37 = prop37.mainsnak.datavalue.value.id
local prop424 = mw.wikibase.getBestStatements(qid37, "P424")[1]
if not prop424 or prop424.mainsnak.snaktype ~= "value" then return end
return prop424.mainsnak.datavalue.value
end
 
Baris 300 ⟶ 335:
-- Dependencies: findLang(); cdate(); dp[]
-------------------------------------------------------------------------------
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",
Baris 345 ⟶ 380:
end
end
-- deal with Julian dates:
local fdate = cdate("", adj, tostring(iso), dp[dprec], bc, "", "", "", "", lang, 1)
-- no point in saying that dates before 1582 are Julian - they are by default
-- doesn't make sense for dates less precise than year
-- we can supress it by setting |plaindate, e.g. for use in constructing categories.
local calendarmodel = ""
if tonumber(year) > 1582
and dprec > 8
and not pd
and model == "http://www.wikidata.org/entity/Q1985786" then
calendarmodel = "julian"
end
if not cdate then
cdate = require("Module:Complex date")._complex_date
end
local fdate = cdate(calendarmodel, adj, tostring(iso), dp[dprec], bc, "", "", "", "", lang, 1)
-- 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("<[^>]*>", "")
-- there may be leading zeros that we should remove
fdate = fdate:gsub("^0*", "")
-- if a plain date is required, then remove any links (like BC linked)
if pd then
fdate = fdate:gsub("%[%[.*|", ""):gsub("]]", "")
end
-- if 'circa', use the abbreviated form *** internationalise later ***
fdate = fdate:gsub('circa ', '<abbr title="circa">c.</abbr>&nbsp;')
Baris 401 ⟶ 456:
local _getSitelink = function(qid, wiki)
qid = (qid or ""):upper()
if qid == "" then returnqid nil= mw.wikibase.getEntityIdForCurrentPage() end
if not qid then return nil end
wiki = wiki or ""
local sitelink
Baris 416 ⟶ 472:
-- _getCommonslink takes an optional qid of a Wikidata entity passed as |qid=
-- It returns one of the following in order of preference:
-- the Commons sitelink of the linked Wikidata itementity - but not if onlycat=true and it's not a category;
-- the Commons sitelink of the topic's main category of the linked Wikidata itementity;
-- the Commons category of the Wikidata entity - unless fallback=false.
-- If the optional parameter onlycat is true/yes/1 then only categories are returned
-- defaults to false.
-------------------------------------------------------------------------------
-- Dependencies: _getSitelink(); parseParam()
Baris 429 ⟶ 483:
if not qid then return nil end
onlycat = parseParam(onlycat, false)
if fallback == "" then fallback = nil end
local sitelink = _getSitelink(qid, "commonswiki")
if onlycat and sitelink and sitelink:sub(1,9) ~= "Category:" then sitelink = nil end
Baris 435 ⟶ 490:
local prop910 = mw.wikibase.getBestStatements(qid, "P910")[1]
if prop910 then
local tmcid = prop910.mainsnak.datavalue and prop910.mainsnak.datavalue.value.id
sitelink = _getSitelink(tmcid, "commonswiki")
end
if not sitelink then
-- check for list's main category
local prop1754 = mw.wikibase.getBestStatements(qid, "P1754")[1]
if prop1754 then
local tmcid = prop1754.mainsnak.datavalue and prop1754.mainsnak.datavalue.value.id
sitelink = _getSitelink(tmcid, "commonswiki")
end
end
end
Baris 443 ⟶ 506:
local prop373 = mw.wikibase.getBestStatements(qid, "P373")[1]
if prop373 then
sitelink = prop373.mainsnak.datavalue and prop373.mainsnak.datavalue.value
if sitelink then sitelink = "Category:" .. sitelink end
end
Baris 460 ⟶ 523:
-- Dependencies: none
-------------------------------------------------------------------------------
local labelOrId = function(id, lang)
if lang == "default" then lang = findLang().code end
local label = mw.wikibase.label(id)
local label
if lang then
label = mw.wikibase.getLabelByLang(id, lang)
else
label = mw.wikibase.label(id)
end
if label then
return mw.text.nowiki(label), true
Baris 490 ⟶ 559:
postfix = postfix or ""
lang = lang or "en" -- fallback to default if missing
-- see if item might need italics or quotes
local fmt = ""
for k, v in ipairs( mw.wikibase.getBestStatements(id, "P31") ) do
if v.mainsnak.datavalue and formats[v.mainsnak.datavalue.value.id] then
fmt = formats[v.mainsnak.datavalue.value.id]
break -- pick the first match
end
end
local disp
local sitelink = mw.wikibase.sitelink(id)
Baris 514 ⟶ 591:
if sitelink then
if not (dtxt or shortname) then
-- strip any namespace or dab from the sitelink and use that as label
local pos = sitelink:find(":") or 0
labellocal slink = sitelink:sub(pos+1):gsub("%s%(.+%)$", ""):gsub(",.+$", "")
-- use that as label, preserving label case - find("^%u") is true for 1st char uppercase
if label:find("^%u") then
label = slink:gsub("^(%l)", string.upper)
else
label = slink:gsub("^(%u)", string.lower)
end
end
if donotlink[label] then
disp = prefix .. fmt .. label .. fmt .. postfix
else
disp = "[[" .. lprefix .. sitelink .. lpostfix .. "|" .. prefix .. fmt .. label .. fmt .. postfix .. "]]"
end
elseif islabel then
Baris 528 ⟶ 611:
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
disp = "[[".. lprefix .. label .. lpostfix .. "|" .. prefix .. fmt .. label .. fmt .. postfix .. "]]"
else
-- no sitelink, label exists, not redirect (or donotlink) so output plain label
disp = prefix .. fmt .. label .. fmt .. postfix
end -- test if article title exists as redirect on current Wiki
else
Baris 685 ⟶ 768:
local createicon = function(langcode, entityID, propertyID)
local icon = "&nbsp;[[" .. i18n["filespace"]
icon = icon .. ":BlueOOjs pencilUI icon edit-ltr-progressive.svg |frameless |text-top |10px |alt="
icon = icon .. i18n["editonwikidata"]
icon = icon .. "|link=https://www.wikidata.org/wiki/" .. entityID
Baris 784 ⟶ 867:
pre = pre or ""
post = post or ""
args.lang = args.lang or findLang().code
-- 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 shortname = parseParam(args.shortname, false)or args.sn
shortname = parseParam(shortname, false)
local snak = propval.mainsnak or propval
local dtype = snak.datatype
local dv = snak.datavalue
local dtype = propval.datatype or propval.mainsnak.datatype
dv = dv and dv.value
-- value and monolingual text language code returned
Baris 832 ⟶ 917:
-- qualifiers (if any) is a nested table or nil
-- lang is given, or user language, or site language
--
val = dateFormat(dv.time, dv.precision, args.df, args.bc, args.pd, propval.qualifiers, args.lang)
-- Here we can check whether args.df has a value
-- If not, use code from Module:Sandbox/RexxS/Getdateformat to set it from templates like {{Use mdy dates}}
val = dateFormat(dv.time, dv.precision, args.df, args.bc, args.pd, propval.qualifiers, args.lang, "", dv.calendarmodel)
------------------------------------
-- data types which are strings:
Baris 841 ⟶ 929:
-- don't link if no linkpre/postfix or linkprefix is just ":"
val = pre .. dv .. post
elseif dtype == "external-id" then
val = "[" .. lpre .. dv .. lpost .. " " .. pre .. dv .. post .. "]"
else
val = "[[" .. lpre .. dv .. lpost .. "|" .. pre .. dv .. post .. "]]"
Baris 857 ⟶ 947:
-- if we have conversions, we won't have formatted numbers or scales
if conv then
uabbr = true
fnum = false
args.scale = "0"
Baris 961 ⟶ 1.052:
end
-- format display:
if conv and usym ~= "" then
if range == "" then
val = mw.getCurrentFrame():expandTemplate{title = "cvt", args = {amount, usymunit}}
else
val = mw.getCurrentFrame():expandTemplate{title = "cvt", args = {lowb, "to", upb, usymunit}}
end
elseif unit == "$" or unit == "£" then
Baris 982 ⟶ 1.073:
-- default is deg/min/sec -- decimal degrees needs |format = dec
local form = (args.format or ""):lower():sub(1,3)
if form ~= "dec" then form = "dms" end -- not needed for now
--
-- show parameter allows just the latitude, or longitudejust tothe belongitude, or shownboth
-- to be returned as a signed decimal, ignoring the format parameter.
local show = (args.show or ""):lower()
if show ~= "longlat" then show = show:sub(1,3) end
Baris 1.108 ⟶ 1.200:
args.pd = pd
 
-- allow qualifiers to have a different date format; default to year
local lang = args.lang
args.qdf = args.qdf or args.qualifierdateformat or args.df or "y"
 
local lang = args.lang or findlang().code
-- 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
-- out[] holds the values for this property
-- mlt[] holds the language code if the datatype is monolingual text
local out = {}
local mlt = {}
Baris 1.121 ⟶ 1.217:
-- no value: it isn't sourced when onlysourced=true
hasvalue = false
elseif qualsonly and qualID then
-- suppress sourced value: only qualifiers are requested
else
out[#out+1]local val, mlt[#out+1]lcode = rendersnak(v, args, linked, lprefix, lpostfix, prefix, postfix, uabbr)
if not val then
hasvalue = false -- rank doesn't match
elseif qualsonly and qualID then
-- suppress value returned: only qualifiers are requested
else
out[#out+1], mlt[#out+1] = val, lcode
end
end
 
-- See if qualifiers are to be returned:
local snak = v.mainsnak or v
if hasvalue and v.qualifiers and qualID and snak.snaktype=~="valuenovalue" then
local qsep = (args.qsep or ""):gsub('"', '')
local qargs = {
Baris 1.141 ⟶ 1.242:
["unitabbr"] = tostring(uabbr),
["maxvals"] = 0,
["sorted"] = tostring(args.qsorted),
["noicon"] = "true",
["list"] = args.qlist,
Baris 1.147 ⟶ 1.248:
["langobj"] = args.langobj,
["lang"] = args.langobj.code,
["df"] = args.qdf
}
local qlist = {}
Baris 1.158 ⟶ 1.260:
local ts = v.qualifiers[v1][1].datavalue.value.time
local dp = v.qualifiers[v1][1].datavalue.value.precision
qlist[#qlist + 1] = dateFormat(ts, dp, args.dfqdf, args.bc, pd, "", lang, "before")
elseif v1 == "P1319" then
local ts = v.qualifiers[v1][1].datavalue.value.time
local dp = v.qualifiers[v1][1].datavalue.value.precision
qlist[#qlist + 1] = dateFormat(ts, dp, args.qdf, args.bc, pd, "", lang, "after")
else
qlist[#qlistlocal + 1]q = assembleoutput(propertyvalueandquals(v.qualifiers[v1], qargs), qargs)
-- we already deal with circa via 'sourcing circumstances'
-- either linked or unlinked *** internationalise later ***
if q ~= "circa" and not (type(q) == "string" and q:find("circa]]")) then
qlist[#qlist + 1] = q
end
end
end
else
-- are there cases where qualifiers-order doesn't exist?
local ql = propertyvalueandquals(v.qualifiers, qargs)
for k1, v1 in ipairs(ql) do
-- we already deal with circa via 'sourcing circumstances'
if k1 == "P1326" then
-- either linked or unlinked *** internationalise later ***
local ts = v1[1].datavalue.value.time
if v1 ~= "circa" and not (type(v1) == "string" and v1:find("circa]]")) then
local dp = v1[1].datavalue.value.precision
qlist[#qlist + 1] = dateFormat(ts, dp, args.df, args.bc, pd, "", lang, "before")
else
qlist[#qlist + 1] = v1
end
Baris 1.195 ⟶ 1.305:
local ts = v1[1].datavalue.value.time
local dp = v1[1].datavalue.value.precision
qlist[#qlist + 1] = dateFormat(ts, dp, args.dfqdf, args.bc, pd, "", lang, "before")
end
end
Baris 1.237 ⟶ 1.347:
-- otherwise look through the fallback languages for a match
if datatype == "monolingualtext" and #out >1 then
lang = mw.text.split( lang, '-', true )[1]
local langcode = args.langobj.code
local fbtbl = mw.language.getFallbacksFor( lang )
langcode = mw.text.split( langcode, '-', true )[1]
table.insert( fbtbl, 1, lang )
local fbtbl = mw.language.getFallbacksFor( langcode )
table.insert( fbtbl, 1, langcode )
local bestval = ""
local found = false
Baris 1.320 ⟶ 1.429:
-- if we've got this far, we have a (sourced) claim with qualifiers
-- so see if matches the required value
-- We'll only deal with wikibase-items and strings for now
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
elseif v1q[qualID][1].datatype == "string" then
if checkvalue(v1q[qualID][1].datavalue.value) then
out[#out + 1] = rendersnak(v1, args, linked, lpre, lpost, pre, post, uabbr, filter)
end
Baris 1.341 ⟶ 1.454:
 
-------------------------------------------------------------------------------
-- _location takes Q-id and follows P276 (location)
-- or P131 (located in the administrative territorial entity) or P706 (located on terrain feature)
-- or P276 (location) or P706 (located on terrain feature)
-- 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).
Baris 1.353 ⟶ 1.466:
first = parseParam(first, false)
skip = parseParam(skip, false)
local locs = {"P276", "P131", "P706"}
local out = {}
local langcode = findLang():getCode()
local finished = false
local count = 0
local prevqid = "Q0"
repeat
local prop
local prop = mw.wikibase.getBestStatements(qid, "P131")[1] or mw.wikibase.getBestStatements(qid, "P276")[1] or mw.wikibase.getBestStatements(qid, "P706")[1]
for i1, v1 in ipairs(locs) do
local proptbl = mw.wikibase.getBestStatements(qid, v1)
if #proptbl > 1 then
-- there is more than one higher location
local prevP131, prevP131id
if prevqid ~= "Q0" then
prevP131 = mw.wikibase.getBestStatements(prevqid, "P131")[1]
prevP131id = prevP131
and prevP131.mainsnak.datavalue
and prevP131.mainsnak.datavalue.value.id
end
for i2, v2 in ipairs(proptbl) do
parttbl = v2.qualifiers and v2.qualifiers.P518
if parttbl then
-- this higher location has qualifier 'applies to part' (P518)
for i3, v3 in ipairs(parttbl) do
if v3.snaktype == "value" and v3.datavalue.value.id == prevqid then
-- it has a value equal to the previous location
prop = proptbl[i2]
break
end -- of test for matching last location
end -- of loop through values of 'applies to part'
else
-- there's no qualifier 'applies to part' (P518)
-- so check if the previous location had a P131 that matches this alternate
if qid == prevP131id then
prop = proptbl[i2]
break
end -- of test for matching previous P131
end
end -- of loop through parent locations
-- fallback to second value if match not found
prop = prop or proptbl[2]
elseif #proptbl > 0 then
prop = proptbl[1]
end
if prop then break end
end
 
-- 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")
Baris 1.371 ⟶ 1.525:
end
end
 
-- get the name of this location and update qid to point to the parent location
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
qid, prevqid = prop.mainsnak.datavalue.value.id, qid
else
-- This is top-level location, so get short name except when this is the first item
-- Use full label if there's no short name or this is the first item
local prop1813 = mw.wikibase.getAllStatements(qid, "P1813")
Baris 1.414 ⟶ 1.570:
count = count + 1
until finished or count >= 10 -- limit to 10 levels to avoid infinite loops
 
-- remove the first location if not quired
if not first then table.remove(out, 1) end
 
-- we might have duplicate text for consecutive locations, so remove them
if #out > 2 then
Baris 1.445 ⟶ 1.604:
end
return out
end
 
 
-------------------------------------------------------------------------------
-- _getsumofparts scans the property 'has part' (P527) for values matching a list.
-- The list (args.vlist) consists of a string of Qids separated by spaces or any usual punctuation.
-- If the matched values have a qualifer 'quantity' (P1114), those quantites are summed.
-- The sum is returned as a number (i.e. 0 if none)
-- a table of arguments is supplied implementing the usual parameters.
-------------------------------------------------------------------------------
-- Dependencies: setRanks; parseParam; parseInput; sourced; assembleoutput;
-------------------------------------------------------------------------------
local _getsumofparts = function(args)
local vallist = (args.vlist or ""):upper()
if vallist == "" then return end
args.reqranks = setRanks(args.rank)
local f = {}
f.args = args
local qid, props = parseInput(f, "", "P527")
if not qid then return 0 end
local onlysrc = parseParam(args.onlysourced or args.osd, true)
local sum = 0
for k1, v1 in ipairs(props) do
if (onlysrc == false or sourced(v1))
and v1.mainsnak.snaktype == "value"
and v1.mainsnak.datavalue.type == "wikibase-entityid"
and vallist:match( v1.mainsnak.datavalue.value.id )
and v1.qualifiers
then
local quals = v1.qualifiers["P1114"]
if quals then
for k2, v2 in ipairs(quals) do
sum = sum + v2.datavalue.value.amount
end
end
end
end
return sum
end
 
Baris 1.453 ⟶ 1.650:
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- _getValue makes the functionality of getValue available to other modules
-- getValue is used to get the value(s) of a property
-- The property ID is passed as the first unnamed parameter and is required.
-- A locally supplied parameter may optionaly be supplied as the second unnamed parameter.
-- The function will now also return qualifiers if parameter qual is supplied
-------------------------------------------------------------------------------
-- Dependencies: setRanks; parseInput; propertyvalueandquals; assembleoutput; parseParam; sourced;
-- labelOrId; i18n.latestdatequalifier; format_Date; makeOrdinal; roundto; decimalPrecision; decimalToDMS;
-------------------------------------------------------------------------------
p.getValue_getValue = function(frameargs)
if not frame.args[1] then
frame.args = frame:getParent().args
if not frame.args[1] then return i18n.errors["No property supplied"] end
end
 
-- parameter sets for commonly used groups of parameters
local paraset = tonumber(frame.args.ps or frame.args.parameterset or 0)
if paraset == 1 then
-- a common setting
frame.args.rank = "best"
frame.args.fetchwikidatarank = "ALLbest"
frame.args.onlysourcedfetchwikidata = "noALL"
frame.args.noicononlysourced = "trueno"
args.noicon = "true"
elseif paraset == 2 then
-- secondequivalent setto goes hereraw
args.rank = "best"
args.fetchwikidata = "ALL"
args.onlysourced = "no"
args.noicon = "true"
args.linked = "no"
args.pd = "true"
elseif paraset == 3 then
-- third set goes here
end
 
-- implement eid parameter
local propertyID = mw.text.trim(frame.args[1] or "")
local eid = args.eid
if eid == "" then
return nil
elseif eid then
args.qid = eid
end
 
local propertyID = mw.text.trim(args[1] or "")
frame.args.reqranks = setRanks(frame.args.rank)
 
args.reqranks = setRanks(args.rank)
local entityid, props = parseInput(frame, frame.args[2], propertyID)
 
local f = {}
f.args = args
local entityid, props = parseInput(f, f.args[2], propertyID)
 
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
local qualID = mw.text.trim(frame.args.qual or ""):upper()
if qualID == "" then qualID = nil end
 
-- set a language object and code in the frame.args table
frame.args.langobj = findLang(frame.args.lang)
frame.args.lang = frame.args.langobj.code
 
-- table 'out' stores the return value(s):
local out = propertyvalueandquals(props, frame.args, qualID)
 
-- format the table of values and return it as a string:
return assembleoutput(out, frame.args, entityid, propertyID)
end
 
 
-------------------------------------------------------------------------------
-- getValue is used to get the value(s) of a property
-- The property ID is passed as the first unnamed parameter and is required.
-- A locally supplied parameter may optionaly be supplied as the second unnamed parameter.
-- The function will now also return qualifiers if parameter qual is supplied
-------------------------------------------------------------------------------
-- Dependencies: _getValue; setRanks; parseInput; propertyvalueandquals; assembleoutput; parseParam; sourced;
-- labelOrId; i18n.latestdatequalifier; format_Date; makeOrdinal; roundto; decimalPrecision; decimalToDMS;
-------------------------------------------------------------------------------
p.getValue = function(frame)
local args= frame.args
if not args[1] then
args = frame:getParent().args
if not args[1] then return i18n.errors["No property supplied"] end
end
 
return p._getValue(args)
end
 
Baris 1.601 ⟶ 1.830:
local onlysrc = parseParam(frame.args.onlysourced or frame.args.osd, true)
 
-- set a language object and language code in the frame.args table
frame.args.langobj = findLang(frame.args.lang)
frame.args.lang = frame.args.langobj.code
 
-- set the requested ranks flags
Baris 1.643 ⟶ 1.873:
end -- of test for success
return nil
end
 
 
-------------------------------------------------------------------------------
-- getSumOfParts scans the property 'has part' (P527) for values matching a list.
-- The list is passed in parameter vlist.
-- It consists of a string of Qids separated by spaces or any usual punctuation.
-- If the matched values have a qualifier 'quantity' (P1114), those quantities are summed.
-- The sum is returned as a number or nothing if zero.
-------------------------------------------------------------------------------
-- Dependencies: _getsumofparts;
-------------------------------------------------------------------------------
p.getSumOfParts = function(frame)
local sum = _getsumofparts(frame.args)
if sum == 0 then return end
return sum
end
 
Baris 1.651 ⟶ 1.897:
-- a property ID (the unnamed parameter or 1=Pxxx)
-- the ID of a qualifier for that property (qualID=Pyyy)
-- either the Wikibase-entity ID of a value for that qualifier (qvalue=Qzzz)
-- or a string value for that qualifier (qvalue=abc123)
-- The usual whitelisting, blacklisting, onlysourced, etc. are implemented
-------------------------------------------------------------------------------
Baris 1.681 ⟶ 1.928:
-------------------------------------------------------------------------------
p.getValueByLang = function(frame)
 
-- The language code for the qualifier we want to match is in named parameter |lang=
local langcode = findLang(frame.args.lang or "").code
if langcode == "" then
langcode = frame:callParserFunction{ name = "int", args = "lang" }
end
local function checkLanguage(id)
-- id should represent a language like "British English (Q7979)"
Baris 1.702 ⟶ 1.945:
-------------------------------------------------------------------------------
-- getValueByRefSource gets the value of a property which has a reference "stated in" (P248)
-- whose value has the given entity code-ID.
-- The call needs:
-- a property ID (the unnamed parameter or 1=Pxxx)
Baris 2.031 ⟶ 2.274:
args.noicon = "true"
return assembleoutput(out, args, qid, pid1)
end
 
 
-------------------------------------------------------------------------------
-- qualsToTable takes most of the usual parameters.
-- The usual whitelisting, blacklisting, onlysourced, etc. are implemented.
-- A qid may be given, and the first unnamed parameter is the property ID, which is of type wikibase item.
-- It takes a list of qualifier property IDs as |quals=
-- For a given qid and property, it creates the rows of an html table,
-- each row being a value of the property (optionally only if the property matches the value in |pval= )
-- each cell being the first value of the qualifier corresponding to the list in |quals
-------------------------------------------------------------------------------
-- Dependencies: parseParam; setRanks; parseInput; sourced;
-------------------------------------------------------------------------------
p.qualsToTable = function(frame)
local args = frame.args
 
local quals = args.quals or ""
if quals == "" then return "" end
 
args.reqranks = setRanks(args.rank)
 
local propertyID = mw.text.trim(args[1] or "")
local f = {}
f.args = args
local entityid, props = parseInput(f, "", propertyID)
if not entityid then return "" end
 
args.langobj = findLang(args.lang)
args.lang = args.langobj.code
 
local pval = args.pval or ""
 
local qplist = mw.text.split(quals, "%p") -- split at punctuation and make a sequential table
for i, v in ipairs(qplist) do
qplist[i] = mw.text.trim(v):upper() -- remove whitespace and capitalise
end
 
local col1 = args.firstcol or ""
if col1 ~= "" then
col1 = col1 .. "</td><td>"
end
 
local emptycell = args.emptycell or "&nbsp;"
 
-- construct a 2-D array of qualifier values in qvals
local qvals = {}
for i, v in ipairs(props) do
local skip = false
if pval ~= "" then
local pid = v.mainsnak.datavalue and v.mainsnak.datavalue.value.id
if pid ~= pval then skip = true end
end
if not skip then
local qval = {}
local vqualifiers = v.qualifiers or {}
-- go through list of wanted qualifier properties
for i1, v1 in ipairs(qplist) do
-- check for that property ID in the statement's qualifiers
local qv, qtype
if vqualifiers[v1] then
qtype = vqualifiers[v1][1].datatype
if qtype == "time" then
qv = mw.wikibase.renderSnak(vqualifiers[v1][1])
qv = frame:expandTemplate{title="dts", args={qv}}
elseif qtype == "url" then
qv = mw.wikibase.renderSnak(vqualifiers[v1][1])
local display = qv:match("([%w_]+)$"):gsub("_", " ")
if display then
qv = "[" .. qv .. " " .. display .. "]"
end
else
qv = mw.wikibase.formatValue(vqualifiers[v1][1])
end
end
-- record either the value or a placeholder
qval[i1] = qv or emptycell
end -- of loop through list of qualifiers
-- add the list of qualifier values as a "row" in the main list
qvals[#qvals+1] = qval
end
end -- of for each value loop
 
local out = {}
for i, v in ipairs(qvals) do
out[i] = "<tr><td>" .. col1 .. table.concat(qvals[i], "</td><td>") .. "</td></tr>"
end
return table.concat(out, "\n")
end
 
Baris 2.115 ⟶ 2.446:
local itemID = mw.text.trim(frame.args[1] or frame.args.qid or "")
if itemID == "" then return end
local labellang = labelOrId(itemID)frame.args.lang or ""
if lang == "" then lang = nil end
local label = labelOrId(itemID, lang)
return label
end
Baris 2.121 ⟶ 2.454:
 
-------------------------------------------------------------------------------
-- getAT (Article Title)
-- 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.
-- If there is no sitelink, it returns nothing.
Baris 2.238 ⟶ 2.572:
-- optional boolean parameter first toggles the display of the first item
-- optional boolean parameter skip toggles the display to skip to the last item
-- parameter debug=<y/n> (default 'n') adds error msg if not a location
-------------------------------------------------------------------------------
-- Dependencies: _location();
-------------------------------------------------------------------------------
p.location = function(frame)
local debug = (frame.args.debug or ""):sub(1, 1):lower()
if debug == "" then debug = "n" end
local qid = mw.text.trim(frame.args.qid or frame.args[1] or ""):upper()
if qid == "" then return "No id supplied"qid=mw.wikibase.getEntityIdForCurrentPage() end
if not qid then
if debug ~= "n" then
return i18n.errors["entity-not-found"]
else
return nil
end
end
local first = mw.text.trim(frame.args.first or "")
local skip = mw.text.trim(frame.args.skip or "")
Baris 2.310 ⟶ 2.654:
-------------------------------------------------------------------------------
p.labelorid = function(frame)
local label =return labelOrId( frame.args.qid or frame.args[1] )
return label
end
 
Baris 2.328 ⟶ 2.671:
end
return langcode
end
 
 
-------------------------------------------------------------------------------
-- getItemLangCode takes a qid parameter (using the current page's qid if blank)
-- If the item for that qid has property country (P17) it looks at the first preferred value
-- If the country has an official language (P37), it looks at the first preferred value
-- If that official language has a language code (P424), it returns the first preferred value
-- Otherwise it returns nothing.
-------------------------------------------------------------------------------
-- Dependencies: _getItemLangCode()
-------------------------------------------------------------------------------
p.getItemLangCode = function(frame)
return _getItemLangCode(frame.args.qid or frame.args[1])
end
 
Baris 2.348 ⟶ 2.705:
-- getQid returns the qid, if supplied
-- failing that, the Wikidata entity ID of the "category's main topic (P301)", if it exists
-- failing that, the Wikidata entity ID asociatedassociated with the curentcurrent page, if it exists
-- otherwise, nothing
-------------------------------------------------------------------------------
Baris 2.372 ⟶ 2.729:
 
-------------------------------------------------------------------------------
-- followQid takes twothree optional parameters: qid, props, and propsall.
-- If qid is not given, it uses the qid for the connected page
-- or returns nil if there isn't one.
Baris 2.378 ⟶ 2.735:
-- 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,
-- and the search terminates, unless |all=y when all of the qids are returned, sparated by spaces.
-- If props is not given, the qid is returned.
-------------------------------------------------------------------------------
-- Dependencies: noneparseParam()
-------------------------------------------------------------------------------
p.followQid = function(frame)
local qid = (frame.args.qid or ""):upper()
local all = parseParam(frame.args.all, false)
if qid == "" then
qid = mw.wikibase.getEntityIdForCurrentPage()
end
if not qid then return nil end
local out = {}
 
local props = (frame.args.props or ""):upper()
if props ~= "" then
Baris 2.397 ⟶ 2.755:
local linkedid = v.mainsnak.datavalue and v.mainsnak.datavalue.value.id
if linkedid then
returnif linkedidall then
out[#out+1] = linkedid
end
else
return linkedid
end -- test for all or just the first one found
end -- test for value exists for that property
end -- loop through values of property to follow
end -- loop through list of properties to follow
end
if #out > 0 then
 
return qidtable.concat(out, " ")
else
return qid
end
end
 
Baris 2.468 ⟶ 2.833:
return lang:formatNum( num )
end
 
 
-------------------------------------------------------------------------------
Baris 2.731 ⟶ 3.097:
 
 
-------------------------------------------------------------------------------
-- checkValidity checks whether the first unknown parameter represents a valid entity-id,
-- checkValidity checks whether the first unnamed parameter represents a valid entity-id,
-- 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:).
-------------------------------------------------------------------------------
-- Dependencies: none
-------------------------------------------------------------------------------
function p.checkValidity(frame)
local id = mw.text.trim(frame.args[1] or "")
Baris 2.741 ⟶ 3.111:
else
return false
end
end
 
 
-------------------------------------------------------------------------------
-- getEntityFromTitle returns the Entity-ID (Q-number) for a given title.
-- Modification of Module:ResolveEntityId
-- The title is the first unnamed parameter.
-- The site parameter determines the site/language for the title. Defaults to current wiki.
-- The showdab parameter determines whether dab pages should return the Q-number or nil. Defaults to true.
-- Returns the Q-number or nil if it does not exist.
-------------------------------------------------------------------------------
-- Dependencies: parseParam
-------------------------------------------------------------------------------
function p.getEntityFromTitle(frame)
local args=frame.args
if not args[1] then args=frame:getParent().args end
if not args[1] then return nil end
local title = mw.text.trim(args[1])
local site = args.site or ""
local showdab = parseParam(args.showdab, true)
qid = mw.wikibase.getEntityIdForTitle(title, site)
if qid then
local prop31 = mw.wikibase.getBestStatements(qid, "P31")[1]
if not showdab and prop31 and prop31.mainsnak.datavalue.value.id == "Q4167410" then
return nil
else
return qid
end
end
end
Baris 2.751 ⟶ 3.150:
-- List of exported functions
-------------------------------------------------------------------------------
--[[
-- getValue
_getValue
-- getPreferredValue
getValue
-- getCoords
getPreferredValue
-- getQualifierValue
getCoords
-- getValueByQual
getQualifierValue
-- getValueByLang
getSumOfParts
-- getLink
getValueByQual
-- getLabel
getValueByLang
-- getAT
getValueByRefSource
-- getDescription
getPropOfProp
-- getAliases
getAwardCat
-- pageId
getIntersectCat
-- formatDate
getGlobe
-- location
getCommonsLink
-- checkBlacklist
getSiteLink
-- emptyor
getLink
-- labelorid
getLabel
-- getLang
getAT
-- findLanguage
getDescription
-- getQID
getAliases
-- followQid
pageId
-- siteID
formatDate
-- projID
location
-- formatNumber
checkBlacklist
-- examine
emptyor
-- checkvalue
labelorid
-- url2
getLang
-- getWebsite
getItemLangCode
-- getAllLabels
findLanguage
-- getAllDescriptions
getQID
-- getAllAliases
followQid
siteID
projID
formatNumber
examine
checkvalue
url2
getWebsite
getAllLabels
getAllDescriptions
getAllAliases
showNoLinks
checkValidity
getEntityFromTitle
--]]
-------------------------------------------------------------------------------