Karaby: 1 версия импортирована

2025-07-27T15:36:36Z

1 версия импортирована

← Предыдущая версия		Версия от 15:36, 27 июля 2025
(нет различий)

Буквица>The Fox Bot: Защитил страницу Модуль:WDBackend: критический шаблон или модуль: согласно Служебная:Постоянная ссылка/143835923#Промежуточный итог ([Редактирование=только автоподтверждённые] (бессрочно) [Переименование=только автоподтверждённые] (бессрочно))

2025-03-05T16:12:30Z

Защитил страницу Модуль:WDBackend: критический шаблон или модуль: согласно Служебная:Постоянная ссылка/143835923 ([Редактирование=только автоподтверждённые] (бессрочно) [Переименование=только автоподтверждённые] (бессрочно))

Новая страница

require('strict')

local p = {}

local NS_MODULE = 828 --: https://www.mediawiki.org/wiki/Extension_default_namespaces
local moduleNamespace = mw.site.namespaces[NS_MODULE].name

local base = require(moduleNamespace .. ':WDBase')

local Backend = {}

function Backend:new(lang)
local defaultLangObj = mw.getContentLanguage()
local defaultLang = defaultLangObj:getCode()
local obj = {
lang = lang,
defaultLang = defaultLang
}
setmetatable(obj, self)
self.__index = self

return obj
end

function Backend:safeField(source, fieldName, parentField)
if not parentField then
parentField = source
end
local info = parentField[fieldName]
if not info then
info = {}
end
return info
end

function Backend:parseFieldPath(source, map, parentField)
local fieldName = map.name
local currParentComponents = source
local currParentField = nil
if map.isLocal or not fieldName then
currParentField = parentField
if parentField then
currParentComponents = currParentField.components or {}
end
end
if type(fieldName) == 'table' then
local lastParentField = currParentField
local lastParentComponents = currParentComponents
local lastNotFound = false
for i, name in ipairs(fieldName) do
if i ~= 1 then
-- It's much easier to break at last iteration, but it's a problem
-- to get the count of parts if the map will be loaded by mw.loadData()
if lastNotFound then
return nil
end
currParentField = lastParentField
currParentComponents = lastParentComponents
end
if lastParentComponents then
lastParentField = lastParentComponents[name]
lastParentComponents = lastParentField and lastParentField.components
else
lastNotFound = true
end
fieldName = name
end
currParentComponents = currParentComponents or {}
end
return currParentField, currParentComponents, fieldName
end

function Backend:trySetField(source, fieldName, info, parentField)
if info.value or info.entity then
if not parentField then
parentField = source
end
parentField[fieldName] = info
end
end

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

function Backend:getLang(map)
return (map.useDefaultLang and self.defaultLang) or self.lang
end

function Backend:fetchFieldsByQualifiers(source, fieldMap, qualifiers, parentField)
for _, map in ipairs(fieldMap) do
local qualifier = qualifiers[map.property]
if qualifier then
if map.filter then
qualifier = map.filter(qualifier, self:getLang(map))
end
self:fetchFieldByMap(source, map, qualifier, base.dataBySnak, parentField)
end
end
end

function Backend:fetchFieldItem(source, map, statementOrSnak, getData)
local lang = self:getLang(map)
local item = getData(statementOrSnak, lang, map.cache)
if item then
item.retrieved = true
else
item = {}
end
if map.mapEntity then
local entity = map.mapEntity[item.entity]
if not entity then
return nil
end
item = base.dataByEntity(entity, lang, map.cache)
if item then
item.retrieved = true
end
end

if item.entity then
if map.getData then
item = map.getData(item.entity, lang)
item.retrieved = true
elseif map.getValue then
item.value, item.lang = map.getValue(item.entity, lang)
end
end
if map.allowedEntities and item.entity and not inArray(item.entity, map.allowedEntities) then
return nil
end

if map.defaultUnit and not item.unitEntity then
item.unitEntity = map.defaultUnit
end
if map.allowedUnits then
if not item.unitEntity or not inArray(item.unitEntity, map.allowedUnits) then
return nil
end
end

if not item.value and not item.entity then
return nil
end

if map.exact then
item.exact = true
end

return item
end

local function skipGetIf(item, cond)
if not cond then
return false
end

for key, value in pairs(cond) do
if item[key] == value then
return true
end
end

return false
end

function Backend:tryGet(source, map, getTable, items, currParentField)
if not getTable then
return
end

local fieldName = map.name
if fieldName then
for j, item in ipairs(items) do
if not skipGetIf(item, map.skipGetIf) then
self:fetchFieldsByMap(source, item.entity, getTable, item)
end
end
else
for j, item in ipairs(items) do
if not skipGetIf(item, map.skipGetIf) then
self:fetchFieldsByMap(source, item.entity, getTable, currParentField)
end
end
end
end

function Backend:fetchFieldByMap(source, map, statementsOrSnaks, getData, parentField)
local currParentField, currParentComponents, fieldName
= self:parseFieldPath(source, map, parentField)
if not currParentComponents then
return
end

if fieldName then
local fieldTable = self:safeField(source, fieldName, currParentField)
if map.match and getData == base.dataByStatement and fieldTable.value then
local statement = base.searchStatementByValue(statementsOrSnaks, fieldTable.value)
if not statement then
return
end
local item = self:fetchFieldItem(source, map, statement, getData)
if item then
currParentComponents[fieldName] = item
if map.qualifiers and statement.qualifiers then
self:fetchFieldsByQualifiers(source, map.qualifiers, statement.qualifiers, item)
end
local getTable = map.forceGet or map.get
if getTable and not skipGetIf(item, map.skipGetIf) then
self:fetchFieldsByMap(source, item.entity, getTable, currParentField)
end
else
if map.elseGet then
self:fetchFieldsByMap(source, parentField.entity, map.elseGet, currParentField)
end
end
return
end
if fieldTable.value and not map.overwrite then
if map.substInto and map.substInto.force then
self:substFieldInto(source, map, parentField)
end
local items = fieldTable
if table.getn(items) == 0 then
items = { items }
end
self:tryGet(source, map, map.forceGet, items, currParentField)
return
end
end

local maxCount = map.max
if not maxCount then
maxCount = math.huge
end

local items = {}
local indices = {}
for i, statementOrSnak in ipairs(statementsOrSnaks) do
if i > maxCount then
break
end
if statementOrSnak ~= nil then
local item = self:fetchFieldItem(source, map, statementOrSnak, getData)
if item then
table.insert(items, item)
indices[i] = table.getn(items)
else
indices[i] = 0
end
end
end

local triggerElseGet = false
if fieldName then
if table.getn(items) == 1 and not map.isArray then
currParentComponents[fieldName] = items[1]
elseif next(items) ~= nil then
currParentComponents[fieldName] = items
else
triggerElseGet = true
end
elseif next(items) ~= nil then
if map.overwriteValue then
parentField.value = items[1].value
parentField.exact = map.exact
end
if map.overwriteEntity then
parentField.entity = items[1].entity
end
else
triggerElseGet = true
end
if currParentField and next(currParentComponents) ~= nil then
currParentField.components = currParentComponents
end

if map.substInto then
self:substFieldInto(source, map, parentField)
end

for i, statementOrSnak in ipairs(statementsOrSnaks) do
if i > maxCount then
break
end
local item = items[indices[i]]
if map.qualifiers and statementOrSnak.qualifiers then
self:fetchFieldsByQualifiers(source, map.qualifiers, statementOrSnak.qualifiers, item)
end
end

self:tryGet(source, map, map.forceGet or map.get, items, currParentField)

if triggerElseGet and map.elseGet then
self:fetchFieldsByMap(source, parentField.entity, map.elseGet, parentField)
end
end

function Backend:fetchFieldByCustomFunc(source, entity, map, parentField)
local currParentField, currParentComponents, fieldName
= self:parseFieldPath(source, map, parentField)
if not currParentComponents then
return
end

local fieldTable = currParentComponents[fieldName]
if fieldTable and fieldTable.value and not map.overwrite then
return
end

local lang = self:getLang(map)
if map.getData then
fieldTable = map.getData(entity, lang)
else
fieldTable = fieldTable or {}
fieldTable.value = map.getValue(entity, lang)
end
fieldTable.retrieved = true
self:trySetField(source, fieldName, fieldTable, currParentComponents)
if currParentField and next(currParentComponents) ~= nil then
currParentField.components = currParentComponents
end
end

function Backend:fetchFieldLabel(source, map, parentField)
local currParentField, currParentComponents, fieldName
= self:parseFieldPath(source, map, parentField)
if not currParentComponents then
return
end

local fieldTable = currParentComponents[fieldName]
local entity
if fieldTable then
if fieldTable.value then
return
end
entity = fieldTable.entity
end
entity = map.entity or fieldTable.entity
if not entity then
return
end

local components = fieldTable and fieldTable.components
fieldTable = base.dataByEntity(entity, self:getLang(map), map.cache)
fieldTable.components = components
currParentComponents[fieldName] = fieldTable

if currParentField and next(currParentComponents) ~= nil then
currParentField.components = currParentComponents
end
end

local function getPropertyByPath(source, propertyPath)
local currField = source
for _, pathEntry in ipairs(propertyPath) do
currField = currField[pathEntry]
if not currField then
return nil
end
end
return currField
end

local function filterStatementsByPropertiesAndValues(statements, properties)
local filtered = {}
local propsCount = table.getn(properties)
for _, statement in ipairs(statements) do
local matched = 0
local qualifiers = statement.qualifiers
if qualifiers then
for _, propInfo in ipairs(properties) do
local propQualifiers = qualifiers[propInfo.property]
if propQualifiers then
for _, propQualifier in ipairs(propQualifiers) do
if propInfo.value then
local value = base.valueBySnak(propQualifier)
if value == propInfo.value then
matched = matched + 1
else
break
end
else
matched = matched + 1
end
end
end
end
end
if matched == propsCount then
table.insert(filtered, statement)
end
end

if not next(filtered) then
return nil
end
return filtered
end

function Backend:tryForceGetByMap(source, map, parentField)
local currParentField, currParentComponents, fieldName
= self:parseFieldPath(source, map, parentField)
if not currParentComponents then
return
end

local fieldTable = self:safeField(source, fieldName, currParentComponents)
local items = fieldTable
if table.getn(items) == 0 then
items = { fieldTable }
end
self:tryGet(source, map, map.forceGet, items, currParentField)
end

function Backend:substFieldInto(source, map, parentField)
local currParentField, currParentComponents, fieldName
= self:parseFieldPath(source, map, parentField)
if not currParentComponents then
return
end

local fieldTable = currParentComponents[fieldName]
if not fieldTable then
return
end

local targetCurrParentField, targetCurrParentComponents, targetFieldName
= self:parseFieldPath(source, map.substInto, parentField)
if not targetCurrParentComponents then
return
end

local targetFieldTable = self:safeField(source, targetFieldName, targetCurrParentComponents)

local templateCurrParentField, templateCurrParentComponents, templateFieldName
= self:parseFieldPath(source, map.substInto.template, parentField)
if not templateCurrParentComponents then
return
end

local templateFieldTable = templateCurrParentComponents[templateFieldName]
if not templateFieldTable then
return
end

targetFieldTable.value = templateFieldTable.value:gsub('%$1', fieldTable.value)
self:trySetField(source, targetFieldName, targetFieldTable, targetCurrParentComponents)
if targetCurrParentField and next(targetCurrParentComponents) ~= nil then
targetCurrParentField.components = targetCurrParentComponents
end
end

function Backend:fetchFieldsByMap(source, entity, fieldMap, parentField)
for _, map in ipairs(fieldMap) do
local currEntity = entity
if map.entity then
currEntity = map.entity
end
if currEntity then
local propertySpecified = false
local statements

if map.property then
statements = base.statements(currEntity, map.property, map.cache)
propertySpecified = true
elseif map.properties then
statements = base.statementsByProperties(currEntity, map.properties)
propertySpecified = true
elseif map.propertyPath then
local property = getPropertyByPath(source, map.propertyPath)
if property then
statements = base.statements(currEntity, property, map.cache)
end
propertySpecified = true
end

if propertySpecified then
if statements then
if map.filter then
statements = map.filter(statements, self:getLang(map))
end
if map.has then
statements = filterStatementsByPropertiesAndValues(statements, map.has)
end
self:fetchFieldByMap(source, map, statements, base.dataByStatement, parentField)
else
if map.elseGet then
self:fetchFieldsByMap(source, currEntity, map.elseGet, parentField)
end
end
else
if map.getData or map.getValue then
self:fetchFieldByCustomFunc(source, currEntity, map, parentField)
end
if map.getLabel then
self:fetchFieldLabel(source, map, parentField)
end
end
if not propertySpecified or not statements then
self:tryForceGetByMap(source, map, parentField)
end
else
self:tryForceGetByMap(source, map, parentField)
end
end
end

function Backend:fetch(source, fieldsMap)
for _, map in ipairs(fieldsMap) do
local fieldTable = self:safeField(source, map.name)
if next(fieldTable) ~= nil then
if map.get then
self:fetchFieldsByMap(source, fieldTable.entity, map.get, fieldTable)
end
if map.substInto then
self:substFieldInto(source, map)
end
end
end
end

function Backend:fetchEntity(source, entity, fieldMap)
self:fetchFieldsByMap(source, entity, fieldMap)
end

function Backend:ensureLang()
if self.lang then
return
end

self.lang = self.defaultLang
end

function Backend:assertLang()
assert(self.lang, 'No language selected.')
end

function p.new(lang)
return Backend:new(lang)
end

return p

Модуль:WDBackend - История изменений

Karaby: 1 версия импортирована