Module:PersonPaperList

From MaRDI portal
Revision as of 10:33, 13 December 2023 by Tconrad (talk | contribs)

Overview

This Lua module is designed for use in a MediaWiki environment. It provides functionality to execute a SPARQL query and present its results in an HTML table format. The module is particularly tailored for generating tables from SPARQL query results, relevant to specific entities identified by a dynamic parameter.

Dependencies

  • SPARQL Module: Used to execute SPARQL queries.
  • mw.html Module: Utilized for generating HTML content, specifically tables.

Module Functions

buildTableFromSparql(frame)

Generates an HTML table based on the results of a SPARQL query.

Parameters
* frame: The frame object containing arguments passed to the module.
Behavior
* Extracts target1 from frame.args[1]. If target1 is not provided or is empty, the function returns "No records found".
* Constructs and executes a SPARQL query using the target1 value. The query retrieves publication dates and work details related to target1.
* Handles errors in SPARQL query execution and logs them.
* Converts the SPARQL query results (JSON format) into a Lua table.
* Generates an HTML table with predefined headers ("Publication", "Date of Publication") and returns it as a string.

trimAndLower(str)

Utility function for string manipulation.

Parameters
* str: The string to be processed.
Returns
* The trimmed and lowercased version of the input string.

convertJsonToTable(jsonResults)

Converts SPARQL query results in JSON format into a Lua table.

Parameters
* jsonResults: JSON object containing SPARQL query results.
Returns
* A Lua table representing the SPARQL query results.

createHtmlTableWithMergedCols(dataTable, headers)

Creates an HTML table from a Lua data table, with specific column handling.

Parameters
* dataTable: The data table from which the HTML table will be generated.
* headers: A table containing header names for the HTML table.
Behavior
* Generates an HTML table with provided headers.
* Merges the first two columns of data into a single column in the resultant HTML table.
* Skips the third column and includes subsequent columns in the HTML table.
* Returns the HTML table as a string.

Return Value

The module returns a table containing the converted information (publication name and date).

Usage Example

{{#invoke:ModuleName|buildTableFromSparql|Arguments}}

Replace ModuleName with the actual name of the module when invoking it in a MediaWiki template or page. Arguments should be replaced with the appropriate arguments as required by the module's functionality.

Note: For the Debug console, you can use this: 

local mockFrame = { args = { 'Q161115'} }
p.buildTableFromSparql(mockFrame)

local helper = require('Module:HelperMethods')

-- Required modules for SPARQL queries and HTML table generation
local sparql = require('SPARQL')
local mwHtml = require('mw.html')

-- Main table to hold all functions
local p = {}

-- Function to build a HTML table from SPARQL query results
function p.buildTableFromSparql(frame)
	
    -- Retrieve target1 from frame arguments or return error message if not set
	local target1 = frame.args[1]
    if not target1 or target1 == '' then
        return "No records found"
    end    
    
    local height = frame.args[2] or '400px' -- Default height if not specified
    local width = frame.args[3] or '800px' -- Default width if not specified

    -- Constructing the SPARQL query with dynamic entity target1
    local sparqlQuery = [[
PREFIX target1: <https://portal.mardi4nfdi.de/entity/]] .. target1 .. [[>
PREFIX wdt: <https://portal.mardi4nfdi.de/prop/direct/>
PREFIX wd: <https://portal.mardi4nfdi.de/entity/>

SELECT
  ?publication_date
  ?work ?workLabel (CONCAT("/work/", SUBSTR(STR(?work), 32)) AS ?workUrl)

WHERE {
  ?work wdt:P16 target1: .

  OPTIONAL {
    ?work wdt:P28 ?publication_datetime .
    BIND(xsd:date(?publication_datetime) AS ?publication_date)
  }
  
  SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }
}

ORDER BY DESC(?publication_date)
    ]]

	-- Executing the SPARQL query and retrieving results in JSON format
	local jsonResults = sparql.runQuery(sparqlQuery)

	-- Handle error in SPARQL query execution
	if jsonResults and jsonResults.error then
    	mw.log("Error in SPARQL query: " .. tostring(jsonResults.error))
    	return nil
	end
	
	-- Extracting headers from the SPARQL query results
	-- NOTE that these headers are not used since we will use hard coded ones below
	local headers = {}
	if jsonResults and jsonResults.head and jsonResults.head.vars then
		headers = jsonResults.head.vars
	end
	
	-- Hard-code headers
    local headers = {"Publication", "Date of Publication"}

	-- Convert the JSON results into a Lua table
	local dataTable = helper.convertJsonToTable(jsonResults)
	
	-- Generate histogram data
    local histogramData = p.generateHistogramData(dataTable)
    local histogramDataJson = mw.text.jsonEncode(histogramData)
    
    -- mw.log(histogramDataJson) 
    
    -- Create a parent container for both the table and the chart
	local parentContainer = mw.html.create('div')
    	:addClass('parent-container')
    	:css('width', width) -- Set the width as needed

    -- Create chart container
    local chartContainer = mw.html.create('div')
        :addClass('wikiChartContainer')
        :css('height', height)
        :css('width', width)
        :attr('data-chartdata', histogramDataJson)

	local heading = mw.html.create('h2')
    	:wikitext('Publications over time')

    -- Create and return HTML table from the data
    local htmlTable = createHtmlTableWithMergedCols(dataTable, headers)
    
    -- Add the table and chart to the parent container
	parentContainer
    	:node(htmlTable)
        :node(heading)
    	:node(chartContainer)

    -- Combine table and chart in a single HTML structure
--    local combinedHtml = mw.html.create('div')
--        :wikitext(htmlTable)
--        :node(heading)
--        :node(chartContainer)

    return tostring(parentContainer)
end

-- Additional function to generate the histogram data
function p.generateHistogramData(dataTable)
    local yearCounts = {}

    for _, row in ipairs(dataTable) do
        -- Extract the year from the fourth column (publication date)
        local date = row[4]
        if date then  -- Check if the date exists
            local year = date:sub(1, 4)  -- Extract the year

            if year ~= "" then
                yearCounts[year] = (yearCounts[year] or 0) + 1
            end
        end
    end

    local years = {}
    local counts = {}
    for year, count in pairs(yearCounts) do
        table.insert(years, year)
        table.insert(counts, count)
    end

    -- Sort the years to maintain chronological order
    table.sort(years)
    local sortedCounts = {}
    for _, year in ipairs(years) do
        table.insert(sortedCounts, yearCounts[year])
    end

    local chartData = {
        type = 'bar',
        data = {
            labels = years,  -- x-axis labels (years)
            datasets = {{
                label = 'Number of Publications',
                data = sortedCounts,  -- y-axis data (counts)
                backgroundColor = 'rgba(54, 162, 235, 0.2)',
                borderColor = 'rgba(54, 162, 235, 1)',
                hoverBackgroundColor = 'red',
                borderWidth = 1
            }}
        },
        options = {
            scales = {
                y = {
                    beginAtZero = true
                }
            }
        }
    }

    return chartData
end


-- Function to create a HTML table from a Lua table
function createHtmlTableWithMergedCols(dataTable, headers)
	local htmlTable = mwHtml.create('table')
	htmlTable:addClass('wikitable'):attr('border', '1')

	local headerRow = htmlTable:tag('tr')
	
	-- Use the provided headers
    for _, header in ipairs(headers) do
        headerRow:tag('th'):wikitext(header)
    end

	-- The first two columns are merged
	for _, row in ipairs(dataTable) do
		local dataRow = htmlTable:tag('tr')
		local combinedData = '[' .. row[1] .. ' ' .. row[2] .. ']'
		dataRow:tag('td'):wikitext(combinedData)
		
		-- Add subsequent columns, skipping the third one
		for j = 4, #row do
			dataRow:tag('td'):wikitext(row[j])
		end
	end

	return tostring(htmlTable)
end

-- Return the created html table
return p
Retrieved from "https://portal.mardi4nfdi.de/w/index.php?title=Module:PersonPaperList&oldid=11058390"
Powered by MediaWiki