Formular: Wikidata

 - [[
* Modul pentru implementarea caracteristicilor șablonului:
* {{Wikidata}}, {{WikidataQ}}, {{WikidataIdx}}, {{WikidataN}}, {{WikidataLabel}}, {{WikidataDescription}}
* {{WikidataLink}}, {{WikidataId}}, {{WikidataTipo}} și {{WikidataIstanza}}.
* Vă permite să accesați Wikidata într-un mod mai avansat decât {{#property}}.

* În principal rescris și extins de la lansarea inițială la:
* http://test2.wikipedia.org/w/index.php?title=Module:Wikidata&oldid=52322
]]

- ================================================== ============================
- Nu utilizați niciodată mw.wikibase.getEntity, de exemplu doar o singură utilizare a
- mw.wikibase.getEntity („Q183”) mărește utilizarea memoriei cu 7 MB
- pentru Lua și este foarte lent dacă se repetă (utilizați numai în getDatatype,
- numai prin proprietate, deoarece nu există alternative).
- ================================================== ============================

require ( „Modul: fără globali” )

local getArgs = require ( 'Modul: Argumente' ). getArgs
local mConvert = require ( 'Module: Convert' )
local mLanguages = require ( 'Modul: Limbi' )

- Categorie pentru pagini cu erori
local errorCategory = '[[Categorie: intrări de erori ale modulului Wikidata]]'

- Mesaje
local i18n = {
erori = {
[ 'entityid-param-not-provided' ] = "Parametrul '' entityid '' nu este furnizat" ,
[ 'property-param-not-provided' ] = "Parametrul '' proprietatea '' nu este furnizată" ,
[ 'qualifier-param-not-provided' ] = "Parametrul '' calificativul '' nu este furnizat" ,
[ 'value-param-not-provided' ] = "Parametrul '' valoare '' de căutat nu este furnizat" ,
[ 'entity-not-found' ] = 'Entitatea nu a fost găsită' ,
[ 'unknown-claim-type' ] = 'Tip de revendicare necunoscut' ,
[ 'unknown-snak-type' ] = 'Tip de snak necunoscut' ,
[ 'unknown-datavalue-type' ] = 'Tipul de date necunoscut' ,
[ 'unknown-entity-type' ] = 'Tipul de entitate necunoscut'
},
somevalue = "'' valoare necunoscută ''" ,
novalue = "'' fără valoare ''" ,
tipuri de date = {
[ 'commonsMedia' ] = 'fișier media pe Commons' ,
[ 'external-id' ] = 'identificator extern' ,
[ 'geo-shape' ] = 'formă geografică' ,
[ 'globe-coordinate' ] = 'coordonate geografice' ,
[ 'math' ] = 'expresie matematică' ,
[ 'monolingualtext' ] = 'text monolingv' ,
[ 'quantity' ] = 'cantitate' ,
[ 'string' ] = 'șir' ,
[ 'tabular-data' ] = 'date tabulare' ,
[ 'time' ] = 'data și ora' ,
[ 'url' ] = 'URL' ,
[ 'wikibase-item' ] = 'element' ,
[ 'wikibase-property' ] = 'proprietate'
}
}

local p = {}

-------------------------------------------------- -----------------------------
- Formatatori
-------------------------------------------------- -----------------------------

funcție locală errhandler ( msg )
local cat = mw . titlu . getCurrentTitle (). spațiu de nume == 0 și errorCategory sau "
returnează string.format ( '<span class = "error">% s </span>% s' , msg , cat )
Sfârșit

funcția locală FormatList ( valori , ordonate )
local fmt = ordonat și „<ol> <li>% s </li> </ol>” sau „<ul> <li>% s </li> </ul>”
returnează # valori > 0 și string.format ( fmt , mw . text . listToText ( valori , '</li> <li>' , '</li> <li>' )) sau ''
Sfârșit

format funcție localăExtLink ( url )
protocoale locale = { ftp = true , http = true , https = true }

local success, uri = PCALL (function () return mw. uri. new (url) end)
dacă succes și uri . protocol și protocoale [ uri . protocol ] atunci
local dest = tostring ( uri )
return string.format ( '<span style = "word-break: break-all;"> [% s% s] </span>' , dest , dest : gsub ( uri . protocol .. ': //' , '' ))	
altfel
returnează adresa URL
Sfârșit
Sfârșit

funcția locală formatEntityId ( entityId )
local label = mw . wikibase . getLabel ( entityId )
local siteLink = mw . wikibase . getSitelink ( entityId )
local ret
if entityId == mw . wikibase . getEntityIdForCurrentPage () atunci
ret = siteLink
elseif siteLink și eticheta atunci
ret = mw . getContentLanguage (): ucfirst ( etichetă ) == siteLink și
string.format ( '[[% s]]' , etichetă ) sau
string.format ( '[[% s |% s]]' , siteLink , etichetă )
elseif siteLink atunci
ret = string.format ( '[[% s]]' , siteLink )
elseif eticheta atunci
ret = etichetă
altfel
ret = "
Sfârșit
retur ret
Sfârșit

formatul funcției locale Text monolingv ( valoare , argumente )
local ret = "
dacă nu arg. includelang sau args . includelang : match ( '% f [az]' .. value . language .. '% f [^ az]' ) then
dacă nu arg. excludelang sau nu args . excludelang : match ( '% f [az]' .. value . language .. '% f [^ az]' ) then
ret = valoare . text
dacă arg. showlang atunci
ret = mLanguages . limbi ({ valoare . limbă }) .. '& nbsp;' .. ret
Sfârșit
Sfârșit
Sfârșit
retur ret
Sfârșit

format funcție locală TimeWithPrecision ( timp , precizie )
luni locale = {
„Ianuarie” , „februarie” , „martie” , „aprilie” , „mai” , „iunie” ,
„Iulie” , „august” , „septembrie” , „octombrie” , „noiembrie” , „decembrie”
}
local ret , anul , luna , ziua
 
an , lună , zi = oră : meci ( '(% d +)% - (% d% d)% - (% d% d). +' )
an , lună , zi = tonumber ( an ), tonumber ( lună ), tonumber ( zi )
dacă precizie == 9 atunci
ret = an
elseif precision == 10 atunci
ret = luni [ luna ] .. '' .. an
elseif precizie == 11 atunci
ret = zi .. '' .. luni [ luna ] .. '' .. an
ret = ret : gsub ( '^ 1% s' , '1º' )
Sfârșit
dacă precizie > = 9 și precizie <= 11 atunci
ret = ret .. ( timp : sub ( 1 , 1 ) == '-' și 'aC' sau '' )
Sfârșit

retur ret
Sfârșit

format funcție locală Timp ( valoare , argumente )
local ret
 
dacă arg. timp == 'precizie' atunci
ret = valoare . precizie
elseif arg. time == 'calendarmodel' atunci
ret = valoare . calendararmodel
elseif arg. timp == „an” și valoare . precizie > = 9 atunci
ret = formatTimeWithPrecision ( valoare . timp , 9 )
elseif arg. timp == „lună” și valoare . precizie > = 10 atunci
ret = formatTimeWithPrecision ( valoare . timp , 10 )
elseif arg. timp == „zi” și valoare . precizie > = 11 atunci
ret = formatTimeWithPrecision ( valoare . timp , 11 )
elsef not args . timpul atunci
ret = formatTimeWithPrecision ( valoare . timp , valoare . precizie )
Sfârșit

returnează ret sau ''
Sfârșit

formatul funcției locale Globecoordinate ( valoare , args )
local ret
dacă arg. coord == 'latitudine' atunci
ret = valoare . latitudine
elseif arg. coord == 'longitudine' atunci
ret = valoare . longitudine
elseif arg. coord == 'glob' atunci
ret = valoare . glob
altfel
ret = string.format ( '% s,% s' , valoare . latitudine , valoare . longitudine )
Sfârșit
retur ret
Sfârșit

format funcție localăFromPattern ( str , args )
model local = args . model
model = mw . ustring. gsub ( model , ' \\ {' , '{' )
model = mw . ustring. gsub ( model , ' \\ }' , '}' )
întoarce-te mw . getCurrentFrame (): preprocesarea (. mw mesaj newRawMessage (model, str):. neteda ())
Sfârșit

funcția locală formatUserValue ( valoare , argumente )
dacă arg. extlink atunci
value = formatExtLink ( valoare )
Sfârșit
întoarce arg . model și formatFromPattern ( valoare , argumente ) sau valoare
Sfârșit

funcția locală getEntityIdFromValue ( valoare )
prefix local = "
dacă valoarea [ 'entity-type' ] == 'item' atunci
prefix = 'Q'
elseif value [ 'entity-type' ] == 'property' atunci
prefix = 'P'
altfel
error ( i18n . errors [ 'unknown-entity-type' ])
Sfârșit
returnează prefixul .. valoare [ 'numeric-id' ]
Sfârșit

format funcție localăUnitSymbol ( entityId , args )
local ret
pentru _ , lang in ipairs ({ 'mul' , 'it' , 'en' }) do
ret = p . _getProperty ({ 'P5061' , includelang = lang , from = entityId })
dacă ret și ret ~ = '' atunci
pauză
altfel
ret = nul
Sfârșit
Sfârșit
spațiu local = ret == '°' și '' sau ''
dacă ret și args . showunitlink atunci
link local = mw . wikibase . getSitelink ( entityId )
dacă legătură atunci
ret = string.format ( '[[% s |% s]]' , link , ret )
Sfârșit
Sfârșit
return ret și ( spațiu .. ret ) sau ''
Sfârșit

- http://lua-users.org/wiki/SimpleRound
runda funcției locale ( num , idp )
local mult = 10 ^ ( idp sau 0 )
returnează math.floor ( num * mult + 0,5 ) / mult
Sfârșit


formatul funcției locale Cantitate ( valoare , argumente )
local ret = tonumber ( valoare . suma )

if ( args . unitate sau args . showunit ) și valoare . unitate ~ = '1' atunci
local unitId = mw . ustring. potrivire ( valoare . unitate , „Q% d +” )
dacă arg. unitate atunci
local opts = {
showunit = args . showunit ,
showunitlink = args . showunitlink ,
formatnum = args . formatnum ,
rotunjire = args . rotunjire
}
ret = mConvert . _main ( ret , unitId , args . unit , opts )
altfel
- dacă este necesar doar simbolul unității
- fără conversie o primește de la P5061
ret = args . rotunjire și rotunde (r, args. rotunjire) sau ret
dacă arg. formatnum atunci
ret = mw . limba . getContentLanguage (): formatNum ( ret )
Sfârșit
ret = ret .. formatUnitSymbol ( unitId , args )
Sfârșit
elseif arg. formatnum atunci
ret = args . rotunjire și rotunde (r, args. rotunjire) sau ret
ret = mw . limba . getContentLanguage (): formatNum ( ret )
elseif arg. durata și valoarea formatului . unitate ~ = '1' atunci
local unitId = mw . ustring. potrivire ( valoare . unitate , „Q% d +” )
ret = mConvert . _main ( ret , unitId , 'second' )
ret = ret și mw . limba . getContentLanguage ()
: formatDuration ( tonumber ( ret ), { 'days' , 'hours' , 'minutes' , 'seconds' })
Sfârșit

retur ret
Sfârșit

format funcție locală Valoare de date ( valoare de date , tip snakdataty , args )
local ret

dacă valoarea datelor . tastați == 'wikibase-entityid' atunci
local entityId = getEntityIdFromValue ( datavalue . value )
dacă arg. showprop atunci
ret = p . _getProperty ({ args . showprop , n = 1 , from = entityId }) sau "
altfel
ret = args . formatare == „brut” și entityId sau formatEntityId ( entityId )
Sfârșit
datavalue elseif. tastați == „șir” atunci
ret = valoare de date . valoare
dacă arg. extlink și snakdatatype == 'url' atunci
ret = formatExtLink ( ret )
elseif arg. urlencode atunci
ret = mw . uri . codifica ( ret )
Sfârșit
datavalue elseif. tastați == „ text monolingv” atunci
ret = format text monolingv ( valoare de date . valoare , argumente )
datavalue elseif. tastați == „timp” atunci
dacă arg. formatare == „brut” atunci
ret = valoare de date . valoare . timp
altfel
ret = formatTime ( datavalue . value , args )
Sfârșit
datavalue elseif. tastați == 'coordonată globală' atunci
ret = formatGlobecoordinate ( datavalue . value , args )
datavalue elseif. tastați == „cantitate” atunci
ret = formatQuantity ( valoare de date . valoare , argumente )
altfel
error ( i18n . errors [ 'unknown-datavalue-type' ])
Sfârșit

retur ret
Sfârșit

Funcția locală formatSnak (snak, args)
dacă șarpe . snaktype == 'somevalue' atunci
returnează i18n [ 'somevalue' ]
elseif snak . snaktype == 'novalue' atunci
return i18n [ 'novalue' ]
elseif snak . snaktype == „valoare” atunci
întoarcere formatDatavalue (snak. datavalue, snak. datatype, args)
altfel
error ( i18n . errors [ 'unknown-snak-type' ])
Sfârșit
Sfârșit

- Este la plural, deoarece calificatorii pot avea, de asemenea, mai multe valori
- (obținut prin introducerea aceluiași calificativ de două ori)
format funcție locală Calificatori ( revendicare , calificatorId , argumente , rawTable , retTable )
local formattedQualifiers = retTable sau {}

dacă pretinde . calificative și revendicare . qualifiers [ qualifierId ] atunci
calificatori locali = revendicare . calificative [ califierId ]
- cu args.nq selectează doar al n-lea calificativ
dacă arg. nq atunci
n locală = tonumber (args. nq)
calificative = ( n și n <= # calificative ) și { calificative [ n ] } sau {}
Sfârșit
- calificativ filtrat după tipul de tip snak, „valoare” implicită
argumente . snaktype = args . snaktype sau „valoare”
pentru _ , calificativ în ipairs ( calificatori ) do
dacă calificativ . snaktype == args . snaktype sau args . snaktype == 'toate' atunci
local formattedQualifier = formatSnak ( calificativ , args )
dacă este formatat Calificator ~ = " atunci
dacă arg. apoi model
formattedQualifier = formatFromPattern ( formattedQualifier , args )
dacă este formatat Calificator ~ = " atunci
table.insert ( formattedQualifiers , formattedQualifier )
Sfârșit
altfel
table.insert ( formattedQualifiers , formattedQualifier )
Sfârșit
Sfârșit
Sfârșit
Sfârșit
Sfârșit

dacă rawTable atunci
returnează Calificatori formatați
Sfârșit

returnează # formattedQualifiers > 0 și
mw . text . listToText ( formattedQualifiers , args . separator , args . conjuncție ) sau zero
Sfârșit

funcție locală appendQualifiers ( declarație , text , argumente )
local formattedQualifiers = {}
local qualifierIds = mw . text . divizat ( arg . showqualifiers, ',')
for _ , qualifierId in ipairs ( qualifierIds ) do
afirmatie if . qualifiers [ qualifierId ] atunci
local formattedQualifier = formatQualifiers ( declarație , qualifierId , args )
table.insert ( formattedQualifiers , formattedQualifier )
Sfârșit
Sfârșit
dacă # formattedQualifiers > 0 atunci
text = string.format ( '% s (% s)' , text , mw . text . listToText ( Calificatori formatați , ',' , ',' ))
Sfârșit
returnează textul
Sfârșit

format funcție locală Declarație ( declarație , argumente )
dacă nu afirmație . tip sau declarație . tastați ~ = 'declarație' atunci
error ( i18n . errors [ 'unknown-claim-type' ])
Sfârșit
 
local ret = formatSnak ( statement . mainsnak , args )
- eventuale showqualifiers
dacă arg. showqualifiers și enunț . calificative atunci
ret = appendQualifiers ( statement , ret , args )
Sfârșit

retur ret
Sfârșit

formatul funcției locale Declarații ( revendicări , argumente , rawTable )
local formatateStatements = {}

pentru _ , revendicare în ipairs ( revendicări ) do
local formattedStatement = formatStatement ( revendicare , argumente )
dacă este formatatStatement ~ = " atunci
- orice tipar
dacă arg. apoi model
formatatStatement = formatFromPattern ( formatatStatement , argumente )
dacă este formatatStatement ~ = " atunci
table.insert ( formattedStatements , formattedStatement )
Sfârșit
altfel
table.insert ( formattedStatements , formattedStatement )
Sfârșit
Sfârșit
Sfârșit
dacă rawTable atunci
returnează declarațiile formatate
Sfârșit

return (( args . list sau args . ordonat ) și # formatateStatements > 1 ) și
formatList ( formattedStatements , args . orderedlist ~ = zero ) sau 
mw . text . listToText (formattedStatements, args. separator, args. conjuncția)
Sfârșit

-------------------------------------------------- -----------------------------
- Citirea și selecția afirmațiilor
-------------------------------------------------- -----------------------------

- Returnează adevărat dacă instrucțiunea conține calificativul necesar cu o valoare dată (sau una dintre mai multe valori separate prin virgulă)
funcția locală hasQualifierValue ( declarație , qualifierId , qualifierValue )
local ret = false
pentru _ , calificativ în ipairs ( declarație . calificatori [ qualifierId ]) face
local isItem = calificativ . snaktype == 'valoare' și
calificativ . valoare de date . tastați == 'wikibase-entityid'
qualifierValues locale = mw. text . divizat ( calificativValor , ',' )
pentru _, qualifierHas în ipairs (qualifierValues) do
- pentru proprietățile tipului de articol, comparația se efectuează pe id
dacă formatSnak ( calificativ , isItem și { formatting = 'raw' } sau {}) == calificator Are atunci
ret = adevărat
pauză
Sfârșit
Sfârșit
Sfârșit
retur ret
Sfârșit

- Returnează revendicările cu rangul solicitat
funcție locală filterRankValue ( revendicări , rang )
local ret = {}
pentru _ , revendicare în ipairs ( revendicări ) do
dacă pretinde . rang == rang atunci
table.insert ( ret , revendicare )
Sfârșit
Sfârșit
retur ret
Sfârșit

- Returnează o secvență Lua care conține declarațiile pentru proprietatea solicitată,
- de asemenea, gol dacă proprietatea nu există sau nu există valori care să îndeplinească criteriile
- ("rang", "calificativ", "qualifiertype", "fără calificativ", ...).
- Returnează zero numai dacă pagina nu este legată de un element Wikidata și de la nu este indicat.
funcție locală getClaims ( propertyId , args )
local entityId , revendicări , filteredClaims
	
entityId = args . din sau mw . wikibase . getEntityIdForCurrentPage ()
dacă nu entityId atunci
întoarceți zero
Sfârșit
	
- rangul implicit este „cel mai bun”
argumente . rang = args . rang sau „cel mai bun”
dacă arg. rang == „cel mai bun” atunci
revendicări = mw . wikibase . getBestStatements ( entityId , propertyId )
altfel
- declarații filtrate după rang
revendicări = mw . wikibase . getAllStatements ( entityId , propertyId )
revendicări = filterRankValue (revendicari, args. rank)
Sfârșit

- declarații filtrate după tipul de tip snak, „valoare” implicită
argumente . snaktype = args . snaktype sau „valoare”
dacă arg. snaktype și args . snaktype ~ = 'toate' atunci
filteredClaims = {}
pentru _ , revendicare în ipairs ( revendicări ) do
dacă pretinde . mainsnak . snaktype == args . tip snak atunci
table.insert ( filteredClaims , revendicare )
Sfârșit
Sfârșit
revendicări = filteredClaims
Sfârșit

- declarații filtrate după calificativ
dacă arg. calificativ atunci
filteredClaims = {}
pentru _ , revendicare în ipairs ( revendicări ) do
dacă pretinde . calificative și revendicare . calificative [ args . calificativ ] atunci
dacă arg. valoarea calificată atunci
dacă hasQualifierValue ( revendicare , args . calificativ , args . qualifiervalue ) atunci
table.insert ( filteredClaims , revendicare )
Sfârșit
altfel
table.insert ( filteredClaims , revendicare )
Sfârșit
Sfârșit
Sfârșit
revendicări = filteredClaims
Sfârșit

- declarațiile filtrate pentru a fi fără un calificativ
dacă arg. noqualifier atunci
filteredClaims = {}
pentru _ , revendicare în ipairs ( revendicări ) do
dacă nu ( pretinde . calificative și pretinde . calificative [ args . noqualifier ]) atunci
table.insert ( filteredClaims , revendicare )
Sfârșit
Sfârșit
revendicări = filteredClaims
Sfârșit

- instrucțiunile filtrate pentru a nu avea valoare la un anumit calificativ opțional
dacă arg. qualifieroptnovalue și args . valoarea calificată atunci
filteredClaims = {}
pentru _ , revendicare în ipairs ( revendicări ) do
dacă pretinde . calificative și revendicare . calificative [ args . qualifieroptnovalue ] atunci
dacă nu hasQualifierValue (revendicare, args. qualifieroptnovalue, args. qualifiervalue) atunci
table.insert ( filteredClaims , revendicare )
Sfârșit
altfel
table.insert ( filteredClaims , revendicare )
Sfârșit
Sfârșit
revendicări = filteredClaims
Sfârșit

- cu args.qualifiertype = ultimele returnări sunt doar cele mai recente
dacă arg. calificativ și arg . qualifiertype == 'ultimul' atunci
local latest , latestTime
pentru _ , revendicare în ipairs ( revendicări ) do
dacă pretinde . calificative și revendicare . calificative [ args . calificativ ] atunci
pentru _ , calificativ în ipairs ( revendicare . calificatori [ args . calificativ ]) face
dacă calificativ . valoare de date . tastați == „timp” atunci
dacă nu latestTime sau calificativ . valoare de date . valoare . time > latestTime atunci
latest = claim
latestTime = calificativ . valoare de date . valoare . timp
Sfârșit
Sfârșit
Sfârșit
Sfârșit
Sfârșit
revendicări = cele mai recente și {cele mai recente } sau {}
Sfârșit

- cu args.n returnează doar al n-lea element
dacă arg. n atunci
n locală = tonumber (args. n)
revendicări = ( n și n <= # revendicări ) și { revendicări [ n ] } sau {}
Sfârșit

returnează creanțele
Sfârșit

-------------------------------------------------- -----------------------------
- Funcții exportate pentru alte module
-------------------------------------------------- -----------------------------

funcția p. _getClaims ( propertyId , args )
returnează getClaims ( propertyId , args sau {})
Sfârșit

funcția p. _formatStatement ( declarație , argumente )
return formatStatement ( declarație , argumente sau {})
Sfârșit

funcția p. _formatQualifiers ( claim , qualifierId , args , rawTable , retTable )
return formatQualifiers ( revendicare , calificatorId , args sau {}, rawTable , retTable )
Sfârșit

- Returnează valoarea unei proprietăți Wikidata sau zero dacă entitatea sau
- proprietățile nu există sau dacă instrucțiunile sunt zero pentru parametrii de selecție.
funcția p. _getProperty ( args , rawTable )
local propertyId , value , claims , ret

- parametrii poziționali
propertyId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu propertyId atunci
error ( i18n . errors [ 'property-param-not-provided' ], 2 )
Sfârșit
valoare = args [ 2 ]
- fix majuscule
argumente . calificativ = args . calificativ și string.upper (args. calificativ)

dacă valoare atunci
ret = formatUserValue ( valoare , argumente )
elseif arg. wd ~ = 'nu' atunci
revendicări = getClaims ( propertyId , args )
ret = ( revendicări și # revendicări > 0 ) și formatStatements ( revendicări , argumente , rawTable ) sau zero
Sfârșit

retur ret
Sfârșit

- Returnează valoarea unui calificativ al unei proprietăți Wikidata,
- sau nul dacă entitatea sau proprietatea nu există sau dacă nu există rezultate pentru parametrii de selecție.
funcția p. _getQualifier ( args )
local propertyId , qualifierId , value , claims , ret

- parametrii poziționali
propertyId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu propertyId atunci
error ( i18n . errors [ 'property-param-not-provided' ], 2 )
Sfârșit
qualifierId = args [ 2 ] și string.upper ( args [ 2 ])
dacă nu qualifierId atunci
error ( i18n . errors [ 'qualifier-param-not-provided' ], 2 )
Sfârșit
valoare = args [ 3 ]

dacă valoare atunci
ret = formatUserValue ( valoare , argumente )
elseif arg. wd ~ = 'nu' atunci
revendicări = getClaims ( propertyId , args )
dacă revendicări și # revendicări > 0 atunci
local formattedQualifiers = {}
pentru _ , revendicare în ipairs ( revendicări ) do
formattedQualifiers = formatQualifiers ( revendicare , calificatorId , argumente , adevărat , formattedQualifiers )
Sfârșit
ret = # formattedQualifiers > 0 și
mw . text . listToText ( formattedQualifiers , args . separator , args . conjuncție ) sau zero
Sfârșit
Sfârșit

retur ret
Sfârșit

- Returnează indexul declarației cu valoarea solicitată sau zero dacă nu este găsit.
funcția p. _indexOf ( args )
local ret , propertyId , value , claims

- parametrii poziționali
propertyId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu propertyId atunci
error ( i18n . errors [ 'property-param-not-provided' ], 2 )
Sfârșit
valoare = args [ 2 ]
dacă nu valoare atunci
error ( i18n . errors [ 'value-param-not-provided' ], 2 )
Sfârșit

revendicări = getClaims ( propertyId , args )
dacă revendicări și # revendicări > 0 atunci
argumente . formatare = 'brut'
pentru i , revendicare în ipairs ( revendicări ) do
if formatStatement ( revendicare , argumente ) == valoare atunci
ret = i
pauză
Sfârșit
Sfârșit
Sfârșit

retur ret
Sfârșit

- Returnează numărul declarației unei proprietăți Wikidata.
funcția p. _N ( argumente )
local propertyId , revendicări

- parametrii poziționali
propertyId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu propertyId atunci
error ( i18n . errors [ 'property-param-not-provided' ], 2 )
Sfârșit
- primiți creanțe
revendicări = getClaims ( propertyId , args )

returnează revendicări și # revendicări sau 0
Sfârșit

- Returnează adevărat dacă proprietatea specificată are valoarea
- cel puțin una dintre entitățile ID a trecut ca argument.
funcția p. _propertyHasEntity ( propertyId , args )
enunțuri locale = p . _getProperty ({ propertyId , from = args . from , formatting = 'raw' }, true )
dacă afirmații atunci
pentru _ , declarație în ipairs ( declarații ) do
pentru _ , entityId în ipairs ( args ) do
în cazul în care declarația == entityId apoi
întoarce-te adevărat
Sfârșit
Sfârșit
Sfârșit

- Dacă nu a fost găsită nicio valoare, verificați dacă este moștenită
- prin intermediul „subclasei de” proprietate (P279), săpând adânc
- până la epuizarea numărului specificat în args.recursion.
- [[TODO: Evaluează dacă este adecvată o căutare recursivă potențial infinită.
Pentru a face acest lucru, puteți adăuga un parametru maxDepth (opțional)
care îndeplinește funcția curentă de recursivitate și o schimbă pe aceasta din urmă
într-un parametru boolean.
]]
argumente . recursiv = tonumber ( args . recursiv ) sau 0
dacă arg. recursivitate > 0 atunci
recursivitate locală = args . recursivitate
if type ( args . loadedEntities ) ~ = 'table' atunci
argumente . loadedEntities = setmetatable ({}, {
__newindex = funcție ( t , k , v )
set brut ( t , k , v )
set brut ( t , # t + 1 , k )
sfârșit })
argumente . încărcatEntități [ args . din sau mw . wikibase . getEntityIdForCurrentPage ()] = adevărat
Sfârșit
pentru _ , declarație în ipairs ( declarații ) do
dacă nu arg. loadedEntities [ statement ] atunci
argumente . loadedEntities [ statement ] = true
argumente . recursivitate = args . recursivitate - 1
argumente . din = statement
dacă p . _propertyHasEntity ( 'P279' , args ) atunci
reveniți adevărat , argumentează . încărcatEntități
Sfârșit
argumente . recursiv = recursiv
Sfârșit
Sfârșit
Sfârșit
Sfârșit

returnează fals , arg . încărcatEntități
Sfârșit

- Returnează adevărat dacă proprietatea P31 (instanța) are cel puțin una dintre entitățile ID-uri specificate ca valoare
funcția p. _instanceOf ( args )
retur p . _propertyHasEntity ( „P31” , argumente )
Sfârșit

- Returnează adevărat dacă proprietatea P279 (subclasa de) are ca valoare cel puțin una dintre entitatea ID specificată
funcția p. _subclassOf ( args )
retur p . _propertyHasEntity ( 'P279' , args )
Sfârșit

- Returnează eticheta unui articol sau a unei proprietăți Wikidata.
funcția p. _getLabel ( args )
local entityId = args [ 1 ] și string.upper ( args [ 1 ])
local ret
dacă args [ 2 ] atunci
ret = mw . wikibase . getLabelByLang ( entityId , args [ 2 ])
altfel
ret = mw . wikibase . getLabel ( entityId )
Sfârșit
retur ret
Sfârșit

- Returnează descrierea unui articol sau a unei proprietăți Wikidata.
funcția p. _getDescription ( args )
local entityId = args [ 1 ] și string.upper ( args [ 1 ])
local ret = mw . wikibase . getDescription (entityId)
retur ret
Sfârșit

- Returnează titlul paginii conectate la un anumit element Wikidata.
funcția p. _getLink ( argumente ) 
- parametrii poziționali
local entityId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu entityId atunci
error ( i18n . errors [ 'entityid-param-not-provided' ], 2 )
Sfârșit
	
returnează entityId : sub ( 1 , 1 ) == 'Q' și formatEntityId ( entityId ) sau zero
Sfârșit

- Returnează tipul de date al unei proprietăți Wikidata.
funcția p. _getDatatype ( args ) 
local propertyId , entitate

- parametrii poziționali
propertyId = args [ 1 ] și string.upper ( args [ 1 ])
dacă nu propertyId atunci
error ( i18n . errors [ 'property-param-not-provided' ], 2 )
Sfârșit

entity = mw . wikibase . getEntity ( propertyId )
dacă nu entitate atunci
error ( i18n . errors [ 'entity-not-found' ], 2 )
Sfârșit

dacă nu i18n . tipuri de date [ entitate . tip de date ] atunci
error ( i18n . errors [ 'unknown-datavalue-type' ], 2 )
Sfârșit

returnează i18n . tipuri de date [ entitate . tip de date ]
Sfârșit

- Returnează ID-ul articolului Wikidata legat de pagina curentă sau de o pagină specificată
- (notă: urmează redirecționările care se opresc la prima redirecționare legată de un element)
funcția p. _getId ( argumente )
local ret
dacă args [ 1 ] atunci
local title = mw . titlu . nou ( args [ 1 ])
în timp ce titlul face
local id = mw . wikibase . getEntityIdForTitle (titlu. prefixedText)
dacă id atunci
ret = id
pauză
altfel
titlu = title . redirectTarget
Sfârșit
Sfârșit
altfel
ret = mw . wikibase . getEntityIdForCurrentPage ()
Sfârșit
retur ret
Sfârșit

-------------------------------------------------- -----------------------------
- Funcții exportate pentru șabloane
-------------------------------------------------- -----------------------------

- Funcția pentru șablonul {{Wikidata}}
funcția p. getProperty ( cadru )
return select ( 2 , xpcall ( funcție ()
retur p . _getProperty ( getArgs ( cadru , { parentOnly = true }))
end , errhandler ))
Sfârșit

- Funcția pentru șablonul {{WikidataQ}}
funcția p. getQualifier ( cadru )
return select ( 2 , xpcall ( funcție ()
retur p . _getQualifier ( getArgs ( cadru , { parentOnly = true }))
end , errhandler ))
Sfârșit

- Funcția pentru șablonul {{WikidataIdx}}
funcția p. indexOf ( cadru )
return select ( 2 , xpcall ( funcție ()
retur p . _indexOf ( getArgs ( cadru , { parentOnly = true }))
end , errhandler ))
Sfârșit

- Funcția pentru șablonul {{WikidataN}}
funcția p. N ( cadru )
return select ( 2 , xpcall ( function ()
return p . _N ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataLabel}}
function p . getLabel ( frame )
return select ( 2 , xpcall ( function ()
return p . _getLabel ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataDescription}}
function p . getDescription ( frame )
return select ( 2 , xpcall ( function ()
return p . _getDescription ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataLink}}
function p . getLink ( frame )
return select ( 2 , xpcall ( function ()
return p . _getLink ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataIstanza}}
function p . instanceOf ( frame )
return select ( 2 , xpcall ( function ()
return p . _instanceOf ( getArgs ( frame , { parentOnly = true })) and 1 or ''
end , errhandler ))
end

-- Funzione per il template {{WikidataTipo}}
function p . getDatatype ( frame )
return select ( 2 , xpcall ( function ()
return p . _getDatatype ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataId}}
function p . getId ( frame )
return select ( 2 , xpcall ( function ()
return p . _getId ( getArgs ( frame , { parentOnly = true }))
end , errhandler ))
end

-- Funzione per il template {{WikidataValido}}
function p . checkProperty ( frame )
return select ( 2 , xpcall ( function ()
return p . _N ( getArgs ( frame , { parentOnly = true })) > 0 and 1 or ''
end , errhandler ))
end

-- Funzione per il template {{WikidataClasse}}
function p . propertyHasEntity ( frame )
local args = getArgs ( frame , { parentOnly = true })
local propertyId = args [ 1 ]
args . recursion = tonumber ( args . prof ) or 8
return select ( 2 , xpcall ( function ()
return p . _propertyHasEntity ( propertyId , args ) and 1 or ''
end , errhandler ))
end

return p