Modul:SMW

Die Dokumentation für dieses Modul kann unter Modul:SMW/Doku erstellt werden

-- Module:SMW
local p = {}
local concat
local dump
local print
local getArgs = require('Module:Arguments').getArgs

function p.getFullPageTitle(query)
    if not mw.smw then
        return "Semantic MediaWiki-Erweiterung nicht gefunden."
    end

    -- Abfrage ausführen
    local result = mw.smw.ask(query)
    if result then
        for title, _ in pairs(result) do
            return title -- Gibt den ersten gefundenen Seitentitel zurück
        end
    end

    return nil -- Kein Ergebnis gefunden
end

-- Return results
function p.ask(frame)
    if not mw.smw then
        return "Semantic MediaWiki-Erweiterung nicht gefunden."
    end

    -- Argumente extrahieren
    local args = getArgs(frame)
    local query = args[1] -- Die Abfrage ist das erste Argument
    if not query or query == "" then
        return "Keine Abfrage angegeben."
    end

    -- Ergebnisse abrufen
    local queryResult = mw.smw.ask(query)
    if not queryResult then
        return "Keine Ergebnisse gefunden."
    end

    -- Ergebnisse formatieren
    local output = "Abfrage: " .. query .. "\n"
    for title, data in pairs(queryResult) do
        output = output .. "Seite: " .. title .. "\n"
        for key, value in pairs(data) do
            output = output .. "  " .. key .. ": " .. tostring(value) .. "\n"
        end
    end

    return '<pre>' .. output .. '</pre>'
end

function p.getQueryResult(frame)

    if not mw.smw then
        return "mw.smw module not found"
    end

    if frame.args[1] == nil then
        return "no parameter found"
    else
        queryResult = mw.smw.getQueryResult( frame.args )
    end

    if queryResult == nil then
        return "(no values)"
    end

    return '<pre>' .. dump(queryResult) .. '</pre>'
end

-- Return property type
function p.getAttribute(frame)
    if not mw.smw then
        return "Semantic MediaWiki-Erweiterung nicht gefunden."
    end

    local page = frame.args[1]  -- Seitentitel
    local attribute = frame.args[2]  -- Attributname
    if not page or not attribute then
        return "Seite oder Attribut nicht angegeben."
    end

    local query = "[[" .. page .. "]]|?" .. attribute .. "|limit=1"
    local result = mw.smw.ask(query)
    if not result then
        return "Keine Ergebnisse gefunden."
    end

    for title, data in pairs(result) do
        if data[attribute] then
            return tostring(data[attribute])
        end
    end

    return "Attribut nicht gefunden."
end

-- set with return results
function p.set( frame )

    if not mw.smw then
--        return "mw.smw module not found"
            return
    end

    local result = mw.smw.set( frame.args )
    if result == true then
--        return 'Your data was stored successfully'
            return
    else
--        return 'An error occurred during the storage process. Message reads ' .. result.error
            return
    end
end

function p.subobject( frame )

	if not mw.smw then
		return "mw.smw module not found"
	end
    
	local args = getArgs(frame)
	local subobjectId
    if args.subobjectId or args.SubobjectId then
        subobjectId = args.subobjectId or args.SubobjectId
        args.subobjectId = nil
		args.SubobjectId = nil
    end
	local result = mw.smw.subobject( args, subobjectId )
	if result == true then
		return 'Your data was stored successfully in a subobject\n<pre>' .. mw.dumpObject(args) .. '</pre>'
	else
		return 'An error occurred during the subobject storage process. Message reads ' .. result.error
	end
end

function p.info( frame )

	if not mw.smw then
		return "mw.smw module not found"
	end

	if frame.args[1] == nil then
		return "no parameter found"
	end

	return mw.smw.info( frame.args[1], frame.args[2] )
end

--- Concatenates a variable number of strings and numbers to one single string
-- ignores tables, bools, functions, and such and replaces them with the empty string
--
-- What is the benefit of using variable.concat instead of the .. operator?
-- Answer: .. throws an error, when trying to concat bools, tables, functions, etc.
-- This here handels them by converting them to an empty string
--
-- @param ... varaibles to concatenate
--
-- @return string
concat = function(...)
    local args = {...}
    if #args == 0 then
        error('you must supply at least one argument to \'concat\' (got none)')
    end
    local firstArg = table.remove(args, 1)
    if type(firstArg) == 'string' or type(firstArg) == 'number' then
        firstArg = print(firstArg)
    else
        firstArg = ''
    end
    if #args == 0 then
        return firstArg
    else
        return firstArg .. concat(unpack(args))
    end
end

--- This dumps the variable (converts it into a string representation of itself)
--
-- @param entity mixed, value to dump
-- @param indent string, can bu used to set an indentation
-- @param omitType bool, set to true to omit the (<TYPE>) in front of the value
--
-- @return string
dump = function(entity, indent, omitType)
    local entity = entity
    local indent = indent and indent or ''
    local omitType = omitType
    if type( entity ) == 'table' then
        local subtable
        if not omitType then
            subtable = '(table)[' .. #entity .. ']:'
        end
        indent = indent .. '\t'
        for k, v in pairs( entity ) do
            subtable = concat(subtable, '\n', indent, k, ': ', dump(v, indent, omitType))
        end
        return subtable
    elseif type( entity ) == 'nil' or type( entity ) == 'function' or type( entity ) == 'boolean' then
        return ( not omitType and '(' .. type(entity) .. ') ' or '' ) .. print(entity)
    elseif type( entity ) == 'string' then
        entity = mw.ustring.gsub(mw.ustring.gsub(entity, "\\'", "'"), "'", "\\'")
        return concat(omitType or '(string) ', '\'', entity, '\'')
    else
        -- number value expected
        return concat(omitType or '(' .. type( entity ) .. ') ', entity)
    end
end

--- This function prints a variable depending on its type:
-- * tables get concatenated by a comma
-- * bools get printed as true or false
-- * strings and numbers get simple returned as string
-- * functions and nils return as emtpy string
-- @return string
print = function(v)
    if type( v ) == 'table' then
        return table.concat(v, ',')
    elseif type( v ) == 'boolean' then
        return ( v and 'true' or 'false' )
    elseif type(v) == 'string' or type(v) == 'number' then
        return tostring(v)
    else
        return ''
    end
end

return p