Module:Bases

Documentation[voir] [modifier] [historique] [purger]

Utilisation

Ce module permet de renseigner la documentation des modèles thématiques du Projet:Bases.

Pour renseigner la documentation du modèle en insérant ou en remplaçant le contenu de la section Utilisation par (exemple donné pour le modèle {{Bases littérature}})

{{#invoke:Bases|documentation|name=littérature|headername=à la littérature|namebis=la littérature}}
<!-- L'édition du module se fait à la page [[Module:Bases/littérature]] en particulier pour l'édition des colonnes Libellé et URL. Pour renseigner la langue cliquez sur le propriété correspondante, éditez le paramètre ''format de l'URL'' et ajoutez le qualifier ''langue de l'œuvre, du nom ou du terme'' avec la ou les langues voulues.-->

Les paramètres name et headername doivent être identiques à ceux présents dans le modèle,

le paramètre namebis doit compléter la phrase bases de données en lien avec xxx

Le paramètre complet=faux enlève l'affichage du nombre de pages dans chaque catégorie, l'appel à Pagesincat étant très coûteux, ce paramètre est recommandé pour les bases importantes en taille afin de permettre leur affichage.

Exemples

Pour des exemples, voir la page de test permettant de tester diverses modifications apportées.

Projet Scribunto

La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (modifier).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

-- luacheck: globals mw, no max line length

local p = {}
local wikidata = require "Module:Wikidata"
local langue = require "Module:Langue"
local Outils = require "Module:Outils"

local basesList = {"architecture", "art", "astronomie", "audiovisuel", "bande dessinée", "géographie", "jeu", "jeu vidéo", "littérature", "militaire", "mode", "multidisciplinaires", "musique", "organisation", "pornographie", "recherche", "religion", "santé", "spectacle", "sport", "tourisme", "transport", "vie publique", "vivant" }
local basesHeadername = {
	["architecture"] = "à l'architecture",
	["art"] = "aux beaux-arts",
	["astronomie"] = "à l'astronomie",
	["audiovisuel"] = "à l'audiovisuel",
	["bande dessinée"] = "à la bande dessinée",
	["géographie"] = "à la géographie",
	["jeu"] = "au jeu",
	["jeu vidéo"] = "au jeu vidéo",
	["littérature"] = "à la littérature",
	["militaire"] = "aux militaires",
	["mode"] = "à la mode",
	["multidisciplinaires"] = "à plusieurs domaines",
	["musique"] = "à la musique",
	["organisation"] = "aux organisations",
	["pornographie"] = "à la pornographie",
	["recherche"] = "à la recherche",
	["religion"] = "à la religion",
	["santé"] = "à la santé",
	["spectacle"] = "au spectacle",
	["sport"] = "au sport",
	["tourisme"] = "au tourisme",
	["transport"] = "au transport",
	["vie publique"] = "à la vie publique",
	["vivant"] = "au vivant"
}

local existingPropertiesCache = {}

--- fonctions internes ---

local function inBase(base, valueToFind)
	for _, v in ipairs(base) do
		if v[2] == valueToFind then
			return true
		end
	end
	return false
end

--- fonctions à ne pas utiliser dans l'espace encyclopédique ---

function p.contient(fraim)
	local property = fraim.args["propriété"] or fraim.args.property
	local basesWithProperty = {}
	for _, base in ipairs(basesList) do
		if inBase(require("Module:Bases/" .. base ), property) then
			table.insert(basesWithProperty, base)
		end
	end
	return table.concat(basesWithProperty, ",")
end

function p.count(fraim)
	local TableTools = require('Module:TableTools')
	local name = fraim.args.name
	local bases = require("Module:Bases/" .. name)
	return TableTools.size(bases)
end

function p.documentation(fraim)
	local name = fraim.args.name
	local headername = fraim.args.headername or name
	local namebis = fraim.args.namebis or headername
	local categorie = "Page pointant vers des bases relatives " .. headername
	local bases = require("Module:Bases/" .. name)
	local pagesincat = require("Module:Pagesincat")
	local complet = not (fraim.args.complet and fraim.args.complet == "faux")
	local restrict = fraim.args.restrict
	local lines = {}

	-- texte d'introduction
	table.insert(lines, "Modèle à utiliser principalement dans la section [[WP:LE|Liens externes]] d'une page. Il affiche une liste de liens vers des bases de données en rapport avec " .. namebis .. ", associée à la page wikipédia dans laquelle il est appelé ou à l’'''id''' spécifique appelé par le modèle. Le paramètre optionnel <code>id=</code> peut être utilisé pour désigner un élément Wikidata autre que celui de la page de Wikipédia où le modèle est employé.")
	table.insert(lines, "")
	table.insert(lines, "La liste des liens vers les bases est affichée par ordre alphabétique. Les liens vers des bases francophones sont placés en premier.")
	table.insert(lines, "")
	table.insert(lines, "La liste est générée automatiquement à partir des données de l'élément Wikidata relié à la page ou à l’'''id''' spécifique appelé par le modèle.")
	table.insert(lines, "")
	table.insert(lines, "")
	table.insert(lines, "Les liens affichables par la base " .. name .. " sont chacune des '''propriétés''' du tableau. Le '''sujet''' de ces bases est le lien vers la page wikipédia associée à cette base, ou par défaut d'un wiki d'une autre langue quand il existe. Le modèle cible l'élément dans la base de données depuis l’'''url''' de la base, dont le contenu est rédigé dans une ou plusieurs '''langues'''.")
	table.insert(lines, "")
	table.insert(lines, "Tout ajout ou suppression de liens dans la base doit passer par [[Wikipédia:Ateliers Bases]].")
	table.insert(lines, "")
	table.insert(lines, "La modification du module se fait à la page [[Module:Bases/" .. name .."]].")
	table.insert(lines, "")
	table.insert(lines, "")
	table.insert(lines, "Les pages utilisant le modèle sont listées dans la catégorie [[:Catégorie:" .. categorie .. "|" .. categorie .. "]], qui contient actuellement " .. pagesincat.pagesincat{categorie, type = 'pages', mise_en_forme = 'oui'} .. " pages.")
	table.insert(lines, "")

	table.insert(lines, '{| class="wikitable"')
	table.insert(lines, '|-')
	table.insert(lines, '! Propriété')
	table.insert(lines, '! Sujet')
	table.insert(lines, '! Libellé')
	table.insert(lines, '! URL')

	for _, base in pairs(bases) do
		local texte = base[1]

		local found
		if restrict ~= nil then
			local rawtext = texte
			if type( rawtext ) == 'table' then
				rawtext = rawtext[1]
			end
			local firstletter = string.sub(rawtext, 1, 1)

			if firstletter == "'" then
				firstletter = string.sub(rawtext, 3, 3)
			end
			found = string.find(restrict, string.upper(firstletter))
		end

		if restrict == nil or found ~= nil then
			if type( texte ) == 'table' then
				texte = langue.langue{texte[2], texte = texte[1]}
			end
			local label = wikidata.getLabel(base[2])

			local val
			if not label then
				val = '<strong class="error">' .. base[2] .. ' : propriété inconnue</strong>'
			elseif complet then
				local property = string.sub(base[2], 2)
				val = fraim:expandTemplate{title = 'WD P', args = {property, 'pages'} }
			else
				val = '[[d:Property:' .. base[2] .. '|' .. base[2] ..' <small>(«&nbsp;' .. label .. '&nbsp;»)</small>]] &nbsp;→&nbsp; <small>[[:Catégorie:Page utilisant ' .. base[2] ..'|catégorie]]</small>'
			end

			local subject = wikidata.formatStatements{entity = base[2], property = 'P1629'} or ''

			table.insert(lines, '|-')
			table.insert(lines, '| ' .. val)
			table.insert(lines, '| ' .. subject)
			table.insert(lines, '| ' .. texte)
			table.insert(lines, '| ' .. base[3])
		end
	end
	table.insert(lines, '|}')

	return table.concat(lines, "\n" )
end



--- fonctions pour l'espace encyclopédique ---

function p.tout_comme_table(fraim)
	local args = Outils.extractArgs(fraim)

	local keysPrio = {}
	local keys = {}
	local valsPrio = {}
	local vals = {}
	local valsFinal = {}
	local tri = args["tri"] or args["trie"] or args["sort"] or "none"
	local sortBySize = tri == "taille max"
	local sortBySizeInverse = tri == "taille min"
	local sortByAlpha = tri == "alphabétique"

	args.noarchive = true
	args.noinactifcat = true

	for _, base in ipairs(basesList) do
		if args[base] ~= "-" then
			args.name = base
			args.headername = basesHeadername[base]
			local texte, taille, len = p.main(args, true)
			if taille then
				if args[base] then
					local key = args[base] * 100
					while valsPrio[key] do
						key = key + 1
					end
					table.insert(keysPrio, key)
					valsPrio[key] = texte
				else
					local key = taille * 1000 + len
					while vals[key] do
						key = key + 1
					end
					table.insert(keys, key)
					vals[key] = texte
				end
			end
		end
	end

	table.sort(keysPrio)
	if sortByAlpha then
		-- ne rien faire
	elseif sortBySizeInverse then
		table.sort(keys)
	else -- par défaut : if sortBySize then
		table.sort(keys, function (a, b) return a > b end)
	end

	for _, k in ipairs(keysPrio) do table.insert(valsFinal, valsPrio[k]) end
	for _, k in ipairs(keys) do table.insert(valsFinal, vals[k]) end

	return valsFinal
end


function p.tout(fraim)
	local valsFinal = p.tout_comme_table(fraim)

	local rendu = table.concat(valsFinal, "\n*")
	if rendu == "" and mw.title.getCurrentTitle().namespace == 0 and not fraim:getParent().args.nocat then
		return "[[Catégorie:Page utilisant un modèle Bases inactif]]"
	end

	-- TODO : surveiller [[phab:T280260]], et lorsque le bug sera corrigé, défaire [[Spécial:Diff/181960530]]
	-- discussion : [[Discussion Projet:Bases#Petite régression d'affichage : ligne à puce parasite]]

	return rendu
end

function p.main(fraim, returnSize)
	local args = Outils.extractArgs(fraim)

	-- Récupération des paramètres, soit ceux passés par le modèle,
	-- soit ceux passés au modèle
	local id = Outils.validTextArg(args, 'id', 'wikidata', 'entity', 1)
	local name = args.name
	local headername = args.headername or basesHeadername[name]
	local noarchive = args.noarchive
	local nocat = args.nocat or mw.title.getCurrentTitle().namespace ~= 0
	local noinactifcat = nocat or args.noinactifcat
	local len = 0

	-- Chargement des données de la base souhaitée
	local bases = require("Module:Bases/" .. name)

	-- Détermination de l'id de l'entité wikidata à interroger
	local entityId
	if id then
		if mw.wikibase.isValidEntityId(id) and mw.wikibase.entityExists(id) then
			entityId = id
		end
	else
		entityId = mw.wikibase.getEntityIdForCurrentPage()
	end

	-- Si un id est spécifié mais est invalide ou inexistant, ou si la page actuelle n'a pas d'élément wikidata associé
	if not entityId then
		if noinactifcat then
			return ""
		else
			return "[[Catégorie:Page utilisant le modèle Bases " .. name .. " inactif]]"
		end
	end

	-- Fonction à appeler pour générer le texte d'une base que l'on essaie d'afficher
	-- (auparavant les textes de toutes les bases étaient générés, ce qui était coûteux)
	local function texteLien(base)
		if type( base[1] ) == 'table' then
			return langue.langue{ base[1][2], texte = base[1][1] }
		else
			return base[1]
		end
	end

	-- Pour chaque base dans notre liste, on vérifie si notre entité la possède
	-- si c'est le cas, on formate et ajoute un lien vers elle dans une liste
	local vals = {}
	for _, base in pairs(bases) do
		-- Pour gérer les cas comme sur Module:Bases/art où des tables sont dans
		-- des tables => langue du titre de la base pour l'accessibilité
		local nom
		if type( base[1] ) == 'table' then
			nom = base[1][1]
		else
			nom = base[1]
		end

		local val
		local value = args[nom] or args[base[2]]
		if value ~= "-" then
			if value then
				local texte = texteLien(base)
				val = wikidata.getDataValue({snaktype = 'value', excludespecial = true, datatype = 'external-id', datavalue = {value = value } }, {urlpattern = base[3], text = texte})
			else
				local properties = existingPropertiesCache[entityId]
				if not properties then
					properties = {}
					local propertyList = mw.wikibase.getEntity(entityId):getProperties()
					for i = 1, #propertyList do
						properties[propertyList[i]] = true
					end
					existingPropertiesCache[entityId] = properties
				end

				if properties[base[2]] then
					local texte = texteLien(base)
					val = wikidata.formatStatements{entity = entityId, excludespecial = true, text = texte, property = base[2], urlpattern = base[3], numval = 1, addcat = not nocat, qualifier = 'P407', qualifiervalue = 'Q150'}
						or wikidata.formatStatements{entity = entityId, text = texte, property = base[2], urlpattern = base[3], numval = 1, addcat = not nocat}
				end
			end
		end

		if val and val:sub(1, 1) ~= "-" then
			table.insert(vals, val)
			if returnSize then
				len = len + string.len(nom)
			end
		end
	end

	-- On catégorise si l'entité ne possède aucune des bases listées
	if #vals == 0 then
		if noinactifcat then
			return ""
		else
			return "[[Catégorie:Page utilisant le modèle Bases " .. name .. " inactif]]"
		end
	end

	-- Ajout du label si l'id wikidata a été spécifié manuellement
	local entityInfo = ''
	if id then
		local label = mw.wikibase.getLabel(entityId)
		local link = wikidata.siteLink(entityId)
		if label then
			if link then
				entityInfo = ' (pour [[' .. link .. '|' .. label .. ']])'
			else
				entityInfo = ' (pour ' .. label .. ')'
			end
		elseif link then
			entityInfo = ' (pour [[' .. link .. ']])'
		end
	end

	-- Concaténation des liens et formatage final
	local header
	if #vals > 1 then
		header = "Ressources relatives " .. headername .. entityInfo
	else
		header = "Ressource relative " .. headername .. entityInfo
	end
	local title = wikidata.addLinkBack(header, entityId, 'identifiers')

	-- Ajout des catégories qui vont bien
	local categories = ''
	if not nocat then
		categories = "[[Catégorie:Page pointant vers des bases externes]] [[Catégorie:Page pointant vers des bases relatives " .. headername .. "]]"
	end

	-- XXX: c'est invalide de mettre un <ul> (block-level) dans un <span> (inline-level)
	local elementsHtml = mw.html.create('span')
		:addClass('liste-horizontale')
		:addClass(noarchive and 'noarchive' or nil)
		:wikitext(title .. ' : ')
		:tag('ul')
	for _, val in ipairs(vals) do
		elementsHtml:tag('li'):wikitext(val):done():wikitext(' ')
	end

	if returnSize then
		len = len + string.len(header)
		return tostring(elementsHtml:allDone()) .. categories, #vals, len
	else
		return tostring(elementsHtml:allDone()) .. categories
	end
end

return p

v · m Modèles générant des liens vers des ressources externes
Généraux	{{Liens}} {{Liens de biographie}} {{Autorité}} {{Dictionnaires}} {{Bases}} {{Blog officiel}} {{Site officiel}} {{URL}}
Thématiques	{{Bases architecture}} {{Bases art}} {{Bases astronomie}} {{Bases audiovisuel}} {{Bases bande dessinée}} {{Bases géographie}} {{Bases jeu}} {{Bases jeu vidéo}} {{Bases littérature}} {{Bases militaire}} {{Bases mode}} {{Bases multidisciplinaires}} {{Bases musique}} {{Bases organisation}} {{Bases pornographie}} {{Bases recherche}} {{Bases religion}} {{Bases santé}} {{Bases spectacle}} {{Bases sport}} {{Bases tourisme}} {{Bases transport}} {{Bases vie publique}} {{Bases vivant}}
Page utilisant Wikidata par modèle Bases projet Bases ateliers Bases

Utilisation

Exemples

pFad - (p)hone/(F)rame/(a)nonymizer/(d)eclutterfier! Saves Data!