Modul:Wikidata utilities

Die Dokumentation für dieses Modul kann unter Modul:Wikidata utilities/doc erstellt werden

-- Wikidata convenience utilities

-- documentation
local WikidataUtilities = {
	suite  = 'WikidataUtilities',
	serial = '2020-10-01',
	item   = 65439025
}

-- module variable
local wu = {}

-- table storing property ids used
local catTable = {
	P0 = ''
}

local function isSet( arg )
	return arg and arg ~= ''
end

function wu.getEntity( id )
	local wrongQualifier = false
	local entity = nil
	
	if not isSet( id ) then
		return '', entity, wrongQualifier
	end
	if mw.wikibase.isValidEntityId( id ) then
		-- expensive function call
		-- redirect ids marked false, too
		entity = mw.wikibase.getEntity( id )
	end
	if not entity then
		id = ''
		wrongQualifier = true
	end

	return id, entity, wrongQualifier
end

function wu.getEntityId( id )
	local wrongQualifier = false
	local entity = nil
	
	if not isSet( id ) then
		id = ''
	elseif mw.wikibase.isValidEntityId( id ) and mw.wikibase.entityExists( id ) then
		-- expensive function call
		-- redirect ids marked false, too
		entity = id
	else
		id = ''
		wrongQualifier = true
	end

	return id, entity, wrongQualifier
end

function wu.getLabel( entity, lang )
	if not isSet( entity ) then
		return nil
	end
	if type( entity ) == 'string' then -- entity is id
		return isSet( lang ) and mw.wikibase.getLabelByLang( entity, lang )
			or mw.wikibase.getLabel( entity )
	else -- entity is table
		return isSet( lang ) and entity:getLabel( lang ) or entity:getLabel()
	end
end

function wu.getSitelink( entity, globalSiteId )
	if not isSet( entity ) then
		return nil
	end
	if type( entity ) == 'string' then -- entity is id
		return isSet( globalSiteId ) and mw.wikibase.getSitelink( entity, globalSiteId )
			or mw.wikibase.getSitelink( entity )
	else -- entity is table
		return isSet( globalSiteId ) and entity:getSitelink( globalSiteId )
			or entity:getSitelink( globalSiteId )
	end
end

function wu.getBestStatements( entity, p )
	if type( entity ) == 'string' then
		return mw.wikibase.getBestStatements( entity, p )
	else
		return entity:getBestStatements( p )
	end
end

function wu.getStatements( entity, p, count )
	local ar = {}
	if not ( isSet( entity ) and isSet( p ) ) then
		return ar
	end

	local statements = wu.getBestStatements( entity, p )
	count = math.min( count or #statements, #statements )
	if count <= 0 then
		return ar
	end

	local i = 0
	repeat
		i = i + 1
		if statements[ i ].mainsnak.snaktype == 'value' then
			table.insert( ar, statements[ i ] )
		end
	until i >= #statements or #ar >= count

	return ar
end

function wu.getValue( entity, p )
	local statements = wu.getStatements( entity, p, 1 )
	if #statements > 0 then
		catTable[ p ] = ''
		return statements[ 1 ].mainsnak.datavalue.value
	else
		return ''
	end
end

function wu.getId( entity, p )
	local value = ''
	local statements = wu.getStatements( entity, p, 1 )
	if #statements > 0 then
		value = statements[ 1 ].mainsnak.datavalue.value
		value = value.id or ''
		if value ~= '' then
			catTable[ p ] = ''
		end
	end
	return value
end

function wu.getValues( entity, p, count )
	local statements = wu.getStatements( entity, p, count )
	if #statements > 0 then
		catTable[ p ] = ''
		for i = 1, #statements, 1 do
			statements[ i ] = statements[ i ].mainsnak.datavalue.value
		end
	end
	return statements
end

function wu.getValuesByLang( entity, p, count, lang )
	local ar = {}
	local statements = wu.getStatements( entity, p, count )
	if #statements > 0 then
		local value
		for i = 1, #statements, 1 do
			value = statements[ i ].mainsnak.datavalue.value
			if value.language and lang == value.language then
				table.insert( ar, value.text )
			end
		end
	end
	if #ar > 0 then
		catTable[ p ] = ''
	end
	return ar
end	

-- get values array for monolingual text
function wu.getMonolingualValues( entity, p )
	local result = {}
	local statements = wu.getStatements( entity, p, nil )
	if #statements > 0 and statements[ 1 ].mainsnak.datatype == 'monolingualtext' then
		local hyphen, lng, value
		catTable[ p ] = ''
		for i = 1, #statements, 1 do
			value = statements[ i ].mainsnak.datavalue.value
			lng = value.language
			hyphen = lng:find( '-' )
			if hyphen then
				lng = lng:sub( 1, hyphen - 1 )
			end
			if not result[ lng ] then
				result[ lng ] = value.text
			end
		end
	end
	return result
end

function wu.getValuesByQualifier( entity, p, qualifierP, defaultId )
	local result = {}
	if not isSet( qualifierP ) then
		return result
	elseif type( defaultId ) ~= 'string' or defaultId == '' then
		defaultId = 'unknown'
	end

	local statements = wu.getStatements( entity, p, nil )
	if #statements > 0 then
		catTable[ p ] = ''
		local id, value
		for _, statement in ipairs( statements ) do
			-- defaultId is used if a qualifier is missing
			id = defaultId
			value = statement.mainsnak.datavalue.value
			if statement.qualifiers and statement.qualifiers[ qualifierP ] then
				for _, qualifier in ipairs( statement.qualifiers[ qualifierP ] ) do
					if qualifier.snaktype == 'value' then
						id = qualifier.datavalue.value.id
						if id then
							break
						end
					end
				end
			end
			result[ id ] = value
		end
	end
	return result
end

local function analyzeDatavalue( datavalue )
	local v = datavalue.value
	local t = datavalue.type
	if type( v ) == 'table' then
		-- items which can be reduced to a string
		if t == 'wikibase-entityid' then
			v = v.id
		elseif t == 'quantity' then
			if v.unit == '1' then
				v = tonumber( v.amount ) or 1
			else
				v.amount = v.amount:gsub( '^+', '' )
				v.unit = v.unit:gsub( 'http://www.wikidata.org/entity/', '' )
			end
		elseif t == 'time' then
			v = v.time
		end
	end
	return v, t
end

-- The following function is an experimental one, not for extensive use
function wu.getValuesWithQualifiers( entity, p, qualifiers, count, labelFct, ... )
	local array
	local function toQualifierTable( key, qualTab )
		local v
		if not array[ key ] then
			array[ key ] = {}
		end
		for _, qual in ipairs( qualTab ) do
			if qual.snaktype == 'value' then
				v, array[ key .. '-type' ] =
					analyzeDatavalue( qual.datavalue )
				table.insert( array[ key ], v )
			end
		end
		if #array[ key ] == 0 then
			array[ key ] = nil
			array[ key .. '-type' ] = nil
		else
			wu.addProperty( key )
		end
	end

	local results = {}
	local statements = wu.getStatements( entity, p, count )
	if #statements == 0 then
		return results
	end

	if type( qualifiers ) == 'string' then
		qualifiers = { qualifiers }
	end

	for _, statement in ipairs( statements ) do
		array = { value = analyzeDatavalue( statement.mainsnak.datavalue ),
			[ 'value-type' ] = statement.mainsnak.datavalue.type }
		if statement.qualifiers then
			if not qualifiers then -- all qualifier properties
				for key, qualTab in pairs( statement.qualifiers ) do
					toQualifierTable( key, qualTab )
				end
			else -- table of selected qualifier properties
				for _, key in ipairs( qualifiers ) do
					if statement.qualifiers[ key ] then
						toQualifierTable( key, statement.qualifiers[ key ] )
					end
				end
			end
		end
		table.insert( results, array )
	end

	-- clustering statements with identical value
	local helper = {}
	local sort1 = 0
	for _, result in ipairs( results ) do
		if helper[ result.value ] then
			helper[ result.value ].sort2 = helper[ result.value ].sort2 + 1
		else
			sort1 = sort1 + 1
			helper[ result.value ] = { sort1 = sort1, sort2 = 1 }
		end
		result.sort1 = helper[ result.value ].sort1
		result.sort2 = helper[ result.value ].sort2
	end
	if #results > 2 then
		table.sort( results,
			function( a, b )
				return a.sort1 < b.sort1 or 
					( a.sort1 == b.sort1 and a.sort2 < b.sort2 )
			end
		)
	end

	return results
end

function wu.getAliases( entity, lang )
	if type( entity ) == 'string' then -- is Q id
		entity = mw.wikibase.getEntity( entity )
	end
	if not lang then
		lang = mw.getContentLanguage():getCode()
	end
	local aliases = {}
	if entity and entity.aliases and entity.aliases[ lang ] then
		for _, alias in ipairs( entity.aliases[ lang ] ) do
			table.insert( aliases, alias.value )
		end
	end
	return aliases
end

-- maintenance utilities
function wu.addProperty( p )
	catTable[ p ] = ''
end

function wu.getCategories( formatStr )
	local result = ''

	if not isSet( formatStr ) then
		formatStr = '[[Category:%s]]'
	end

	catTable.P0 = nil
	for key, value in pairs( catTable ) do
		result = result .. string.format( formatStr, key )
	end
	return result
end

-- similar function like Modul:Failsafe
function wu._failsafe( version, moduleInterface )
	if type( moduleInterface ) ~= 'table' then
		return false
	end

	local i, parent, v

	-- check if version is a frame table
	if type( version ) == 'table' and type( version.args ) == 'table' then
		v = version.args[ 1 ]
		if not v and type( version.getParent ) == 'function' then
			parent = version:getParent()
			if parent then
				v = parent.args[ 1 ]
			end
		end
		version = v
	end
	-- version should be a string
	if type( version ) == 'string' then
		-- check if empty string
		version = mw.text.trim( version )
		if version == '' then
			version = nil
		end
	else
		version = nil
	end

	-- getting version from Wikidata
	if version == 'wikidata' then
		version = nil
		i = moduleInterface.item
		if type( i ) == 'number' and i > 0 then
			v = wu.getValue( 'Q' .. i, 'P348' )
			if v ~= '' then
				return v
			end
		end
	end

	if not moduleInterface.serial then
		return false
	elseif not version or version <= moduleInterface.serial then
		return moduleInterface.serial
	else
		return false
	end
end

-- module administration
function wu.getModuleInterface()
	return WikidataUtilities
end

function wu.failsafe( version )
	return wu._failsafe( version, WikidataUtilities ) or ''
end

return wu