Lugiak: naimportována 1 revize

2018-06-20T12:05:39Z

naimportována 1 revize

Matěj Suchánek: filtr podle přítomnosti českého článku

2017-12-28T13:19:16Z

filtr podle přítomnosti českého článku

Nová stránka

require 'Modul:No globals'

local p = {}

local lib = require 'Modul:Wikidata/lib'

local function in_array(value, array)
for _, val in ipairs(array) do
if val == value then
return true
end
end
return false
end

local function checkLimit(array, limit)
local limit = limit and tonumber(limit)
if limit then
return #array >= limit
end
return true
end

local function applyLimit(array, limit)
local limit = limit and tonumber(limit)
while limit and #array > limit do
table.remove(array)
end
end

local function IsInLanguage(snak, langs)
local langs = lib.textToTable(langs)
if snak.datatype ~= 'monolingualtext' then
return error(lib.raiseInvalidDatatype('IsInLanguage', snak.datatype, 'monolingualtext'))
else
return lib.IsSnakValue(snak) and in_array(snak.datavalue.value.language, langs)
end
end

local function filterSnaktype(snak, somevalue, novalue)
local snaktype = snak.snaktype
if snaktype == 'somevalue' then
return somevalue or false
elseif snaktype == 'novalue' then
return novalue or false
end
return lib.IsSnakValue(snak)
end

local function filterBySnaktype(statement, somevalue, novalue)
return filterSnaktype(statement.mainsnak, somevalue, novalue)
end

local function hasSnakTarget(snak, target)
local Formatters = require 'Modul:Wikidata/Formatters'
return Formatters.getRawValue(snak) == target
end

local function filterHasTarget(statement, target)
return hasSnakTarget(statement.mainsnak, target)
end

local function filterHasQualifier(statement, prop, value)
if statement.qualifiers then
prop = prop:upper()
for _, snak in ipairs(statement.qualifiers[prop] or {}) do
if not value or hasSnakTarget(snak, value) then
return true
end
end
end
return false
end

local function filterHasRanks(statement, ranks)
return in_array(statement.rank, ranks)
end

local function filterHasReferences(statement, options)
if statement.references then
if #p.filterReferences(statement.references, options) > 0 then
return true
end
end
return false
end

local function filterSnakHasLabel(snak)
local datatype = snak.datatype
if datatype ~= 'wikibase-item' and datatype ~= 'wikibase-property' then
return error(lib.raiseInvalidDatatype('filterSnakHasLabel', datatype, { 'wikibase-item', 'wikibase-property' }))
end
if lib.IsSnakValue(snak) then
local langs = { 'cs', 'sk', 'en' }
local Formatters = require 'Modul:Wikidata/Formatters'
if lib.getLabelInLanguage(Formatters.getRawValue(snak), langs) then
return true
end
end
return false
end

local function filterHasLabel(statement)
return filterSnakHasLabel(statement.mainsnak)
end

local function filterHasSitelink(statement)
local datatype = statement.mainsnak.datatype
if datatype ~= 'wikibase-item' then
return error(lib.raiseInvalidDatatype('filterHasSitelink', datatype, { 'wikibase-item' }))
end
if lib.IsSnakValue(statement.mainsnak) then
if mw.wikibase.sitelink(Formatters.getRawValue(statement.mainsnak)) then
return true
end
end
return false
end

local function filterItemIsInstance(statement, options)
local datatype = statement.mainsnak.datatype
if datatype ~= 'wikibase-item' and datatype ~= 'wikibase-property' then
return error(lib.raiseInvalidDatatype('filterItemIsInstance', datatype, { 'wikibase-item', 'wikibase-property' }))
end
if lib.IsSnakValue(statement.mainsnak) then
local Module = require 'Modul:Wikidata/Tree'
local Formatters = require 'Modul:Wikidata/Formatters'
local item = Formatters.getRawValue(statement.mainsnak)
if Module.IsInstance(item, options) then
return true
end
end
return false
end

local function filterMainsnakInLanguage(statement, withlang)
return IsInLanguage(statement.mainsnak, withlang)
end

local function filterMainsnakHasUnit(statement, unit)
local datatype = statement.mainsnak.datatype
if datatype ~= 'quantity' then
return error(lib.raiseInvalidDatatype('filterItemIsInstance', datatype, { 'quantity' }))
end
return lib.IsSnakValue(statement.mainsnak) and lib.getItemIdFromURI(statement.mainsnak.datavalue.value.unit) == unit
end

local function filter(array, callback, ...)
local i = #array
while i > 0 do
if not callback(array[i], ...) then
table.remove(array, i)
end
i = i - 1
end
end

local function getValuesFromQualifiers(qualifiers)
local Values = {}
local Formatters = require 'Modul:Wikidata/Formatters'
for key, array in pairs(lib.props) do
for _, prop in ipairs(array) do
for _, snak in ipairs(qualifiers[prop] or {}) do
if lib.IsSnakValue(snak) then
Values[key] = Formatters.getRawValue(snak)
break
end
end
end
end
return Values
end

function p.filterStatementsFromEntity(entity, options)
if not options.property or options.property == '' then
return error(lib.formatError('param-not-provided', 'property'))
end
if not entity or not entity.claims then
return {}
end
local property = mw.ustring.upper(options.property)
local statements = mw.clone(entity.claims[property])
if not statements then
return {}
end

p.filterStatements(statements, options)
return statements
end

function p.filterStatements(statements, options)
local options = lib.common.cleanArgs(options)
-- apply filter by rank
local rank = options.rank or "valid"
if rank ~= "all" then
if rank == "valid" or rank == "best" then
filter(statements, filterHasRanks, { "normal", "preferred" })
if rank == "best" and #statements > 0 then
for _, statement in ipairs(statements) do
if statement.rank == "preferred" then
filter(statements, filterHasRanks, { "preferred" })
break
end
end
end
else
filter(statements, filterHasRanks, { rank })
end
if #statements == 0 then return end
end
-- apply filter by source
if options.ref then
filter(statements, filterHasReferences, options)
if #statements == 0 then return end
end
-- apply filter by snak type
filter(statements, filterBySnaktype, options.somevalue and true, options.novalue and true)
if #statements == 0 then return end
-- apply filter by target value
if options.withtarget then
filter(statements, filterHasTarget, options.withtarget)
if #statements == 0 then return end
end
-- apply filter by qualifier property
if options.withqualifier then
filter(statements, filterHasQualifier, options.withqualifier, options.withqualifiervalue)
if #statements == 0 then return end
end
-- apply filter by language
if options.withlang then
filter(statements, filterMainsnakInLanguage, options.withlang)
if #statements == 0 then return end
end
-- apply filter by unit
if options.withunit then
filter(statements, filterMainsnakHasUnit, options.withunit)
if #statements == 0 then return end
end
-- apply filter by time
if options.date then
local date
local Time = require 'Modul:Time'
if type(options.date) == 'table' then
date = options.date
elseif options.date == '#now' then
date = Time.new(os.date('!*t'))
else
date = Time.newFromIso8601(options.date)
end
if not date then
return error(lib.formatError('invalid-date', tostring(options.date)))
end

local oldStatements = mw.clone(statements)
while #statements > 0 do table.remove(statements) end
for _, statement in ipairs(oldStatements) do
local Values = getValuesFromQualifiers(statement.qualifiers or {})
if Values.point then
if date == Values.point then
filter(statements, function(st)
local val = getValuesFromQualifiers(st.qualifiers).point
if val then
return val == Values.point
end
return true
end)
table.insert(statements, statement)
elseif Values.point < date then
if #statements == 0 then
table.insert(statements, statement)
else
local same, ins
for _, st in ipairs(statements) do
local val = getValuesFromQualifiers(st.qualifiers).point
if val then
if date == Values.point then
same = true
break
end
if val == Values.point or val < Values.point then
ins = true
end
end
end
if ins and not same then
filter(statements, function(st)
local val = getValuesFromQualifiers(st.qualifiers).point
return not val or val == Values.point
end)
table.insert(statements, statement)
end
end
end
else
if Values.begin then
if Values.begin < date then
if not Values.ending then
table.insert(statements, statement)
elseif date < Values.ending then
table.insert(statements, statement)
end
end
elseif Values.ending then
if date < Values.ending then
if not Values.begin then
table.insert(statements, statement)
elseif Values.begin < date then
table.insert(statements, statement)
end
end
end
end
end
if #statements == 0 then return end
end
if lib.IsOptionTrue(options, 'withlabel') then
filter(statements, filterHasLabel)
if #statements == 0 then return end
end
if lib.IsOptionTrue(options, 'withsitelink') then
filter(statements, filterHasSitelink)
if #statements == 0 then return end
end
-- apply filter by class
if options.instance then
filter(statements, filterItemIsInstance, options)
if #statements == 0 then return end
end
-- sort statements if needed
if options.sort then -- patří to sem?
local Sorters = require 'Modul:Wikidata/Sorters'
Sorters.sortStatements(statements, options)
end
-- apply filter by limit
applyLimit(statements, options.limit)
end

function p.filterQualifiers(qualifiers, options)
local options = lib.common.cleanArgs(options)
filter(qualifiers, filterSnaktype, options['qualifiers somevalue'] and true, options['qualifiers novalue'] and true)
if #qualifiers == 0 then return end
if options['qualifiers withlang'] then
filter(qualifiers, IsInLanguage, options['qualifiers withlang'])
if #qualifiers == 0 then return end
end
if lib.IsOptionTrue(options, 'qualifiers withlabel') then
filter(qualifiers, filterSnakHasLabel)
if #qualifiers == 0 then return end
end
if options['qualifiers class'] then
--[[ todo
local datatype = Qualifiers[math.random(#Qualifiers)].datatype
if datatype == 'wikibase-item' or datatype == 'wikibase-property' then
oldQualifiers, Qualifiers = Qualifiers, {}
local Module = require 'Modul:Wikidata/Tree'
local Formatters = require 'Modul:Wikidata/Formatters'
for _, snak in ipairs(oldQualifiers) do
if lib.IsSnakValue(snak) then
local item = Formatters.getRawValue(snak)
if Module.IsInTree(item, options['qualifiers class'], 'P279', 20, {}) then
table.insert(Qualifiers, snak)
end
end
end
if #Qualifiers == 0 then return {} end
else
return error(lib.raiseInvalidDatatype('inClass', datatype, { 'wikibase-item', 'wikibase-property' }))
end
]]--
end
if options['qualifiers sort'] then
local Sorters = require 'Modul:Wikidata/Sorters'
Sorters.sortQualifiers(qualifiers, options)
end
applyLimit(qualifiers, options['qualifiers limit'])
end

function p.filterReferences(references, options)
local options = lib.common.cleanArgs(options)
if options.ref == '#any' then
-- @deprecated
return references
end

local oldReferences, References = references, {}
if options.ref == 'valid' then
local map = (require 'Modul:Wikidata/cite').props
for _, ref in ipairs(oldReferences) do
for _, props in pairs(map) do
for _, prop in ipairs(props) do
if ref.snaks[prop] then
table.insert(References, ref)
end
end
end
end
end

if options.min_ref and not checkLimit(References, options.min_ref) then
return {}
end
-- @deprecated
return References
end

return p

← Starší verze	Verze z 20. 6. 2018, 12:05
(Žádný rozdíl)

Modul:Wikidata/Filterers - Historie editací

Lugiak: naimportována 1 revize

Matěj Suchánek: filtr podle přítomnosti českého článku