Theau 2 : 1 version importée

2021-07-24T10:39:26Z

1 version importée

← Version précédente		Version du 24 juillet 2021 à 10:39
(Aucune différence)

Infobox>JessydeVilly le 9 juillet 2020 à 19:51

2020-07-09T19:51:02Z

Nouvelle page

local p = {}

--
-- Les modules et sous-modules dont on aura besoin
--

-- le module démographie
p.demographie = require("Module:Démographie")
-- le module chartes
p.chartes = require("Module:Chartes")

-- on charge les sous-modules
p.constantes = require("Module:Population de France/Constantes")
p.sources = require("Module:Population de France/Sources")
p.notes = require("Module:Population de France/Notes")
p.donnees = require("Module:Population de France/Données")
p.outils = require("Module:Population de France/Outils")
p.intro = require("Module:Population de France/Introductions")

--[[
fonction récupérant les différentes données et appelant
le module démographie pour l'affichage effectif
--]]
function p.tableau_m(param)
-- le nom de la cible (param. nom ou titre page)
local ttl = mw.title.getCurrentTitle().subpageText
local wlm = false
local vnom = param["nom"] or ttl
local donnees = "Module:Données/" .. vnom .. "/évolution population"

-- on charge les données
local data, wlm = p.donnees.charge_donnees(vnom, false)
if (type(wlm) == "number") then
return p.outils.err_nodata("tableau", donnees, wlm)
end

-- on prépare les paramètres à fournir au module Démographie
local dest = {}

-- éléments constants
dest["largeur_tableau"] = "48em"
dest["taille_police"] = "95%"
dest["marge_interlignes"] = "10px"
dest["hauteur_lignes"] = "110%"
dest["population_fond"] = "#F9F9F9"
dest["style_notes"] = "centré"

-- couleur (on passe par Chartes avec un "truc" pour commune nouvelle)
if (data["division"] == "commune nouvelle") then
dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", "commune", true)
else
dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", data["division"], true)
end

-- le titre du tableau
dest["titre"] = (param["titre"] or p.constantes.titre_tableau)
.. "  <small>[ [[" .. donnees .. "|modifier]] ]</small>"

-- notes
local tmp = p.notes.notes(data, vnom)
if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
dest["notes"] = tmp
end

-- sources
tmp = p.sources.sources(data)
if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
dest["sources"] = tmp
end

-- maintenant on parcours les données elles-mêmes
for annee, pop in pairs(data) do
-- les années sont les éléments numériques du tableau
if (type(annee) == "number") then
-- est-ce qu'on garde l'année ?
if (p.outils.test_annee(annee, data)) then
vpop = tonumber(mw.text.trim(pop["pop"]))
if (vpop > 0) then
dest[annee] = vpop -- on stocke
else
dest[annee] = "-"
end
end
end
end

-- on effectue l'appel terminal et on retourne (et on ajoute la catégorie)
return p.demographie.demographie_m(dest) .. p.constantes.cat_usage
end

-- fonction "wrapper" pour la précédente, pour appel depuis un modèle
function p.tableau(frame)
local param = {}
-- deux paramètres : nom et titre
param["nom"] = p.outils.nettoie(frame.args["nom"] or frame:getParent().args["nom"] or nil)
param["titre"] = p.outils.nettoie(frame.args["titre"] or frame:getParent().args["titre"] or nil)

-- on appelle la vraie fonction
return p.tableau_m(param)
end

--[[
Fonction créant une introduction de population de commune
--]]
function p.introduction_m(param)
local resu
local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("introduction", donnees, wlm)
end
if (data["division"] == "fraction cantonale") then
return p.outils.err_nodata("introduction", donnees, 6) -- pas d'intro pour ça
end

resu = p.intro.introduction(data)

return resu
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.introduction(frame)
local pframe = frame:getParent()
local param = {}
-- récupération de l'unique paramètre (nom)
param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
return p.introduction_m(param)
end

-- fonction de tri utilisée par la fonction suivante
-- tri sur la valeur du 1er élément des éléments
function p.sort_par_annee(el1, el2)
if (el1[1] < el2[1]) then
return true
end
return false
end

--[[
Fonction créant un graphique de population de commune
--]]
function p.graphique_m(param)
local resu
local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("graphique", donnees, wlm)
end
if (data["division"] == "fraction cantonale") then
return p.outils.err_nodata("graphique", donnees, 6) -- pas d'intro pour ça
end

-- seuil (nombre de données) pour afficher
param["seuil"] = tonumber(param["seuil"])
if ((param["seuil"] == nil) or (param["seuil"] <= 0)) then
param["seuil"] = 5 -- valeur par défaut
end

-- "Histogramme population manuel" étant un modèle, on fabrique la structure d'appel
-- ici il faudrait modifier "couleur-barres" qui devrait dépendre de la charte…
prm = { ["largeur"] = 710, ["hauteur"] = 340, ["couleur-fond"] = "rgb(1,1,1)" }
local cb
if (data["division"] == "commune nouvelle") then
cb = p.chartes.charte_m("geographie", "primaire", "commune", true)
else
cb = p.chartes.charte_m("geographie", "primaire", data["division"], true)
end
cb = p.outils.color2rgb(cb)
if (cb == nil) then
prm["couleur-barres"] = "rgb(0.7,0.9,0.7)" -- couleur "par défaut"
else
prm["couleur-barres"] = "rgb(" .. cb .. ")"
end

prm["nom"] = param["nom"]
prm["titre"] = param["titre"] or p.constantes.titre_graphique
prm["max"] = data["popmax"]
-- parcours des données
local tmp = {}
for annee, pop in pairs(data) do
if (type(annee) == "number") then
-- est-ce qu'on garde l'année ?
if (p.outils.test_annee(annee, data) and (type(pop["pop"]) == "number") and (pop["pop"] > 0)) then
table.insert(tmp, { annee, pop["pop"] })
end
end
end

-- tri des éléments
table.sort(tmp, p.sort_par_annee)
-- on insert année / valeur dans l'ordre (histogramme pop… a besoin des données dans l'ordre)
local nb = 1
local nbp = 0
for k, v in pairs(tmp) do
if (v[2] > 0) then
prm[nb] = v[1]
prm[nb+1] = v[2]
nb = nb + 2
nbp = nbp + 1 -- nombre de barres (réel)
end
end
-- si pas assez de données on ne traite pas
if (nbp < param["seuil"]) then
return "" -- on retourne "rien"
end

prm["nombre"] = nbp
prm["sources"] = p.sources.sources_graphique(data)

-- précaution
if (nbp == 0) then
p.outils.err_nodata("graphique", donnees, 7, true)
end

-- on "appelle" le modèle
return mw.getCurrentFrame():expandTemplate{ title = 'Histogramme population manuel', args = prm }
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.graphique(frame)
local pframe = frame:getParent()
local param = {}
-- récupération des paramètre (nom et titre)
param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
param["titre"] = p.outils.nettoie(frame.args["titre"] or pframe.args["titre"] or nil)
param["seuil"] = p.outils.nettoie(frame.args["seuil"] or pframe.args["seuil"] or nil)
return p.graphique_m(param)
end

--[[
Retourne la dernière population (ou la dernière date) pour la commune "nom" (ou courante)
Si prm[1] est vide retourne la population, sans formatage
Si prm[1] vaut "date", retourne la date
Si prm[1] vaut "nombre", idem premier cas mais avec formatage du nombre
Si prm[1] vaut "table", retourne une table avec l'année en 1er élément et le nombre en 2e élément
--]]
function p.derniere_population_m(prm)
local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("derniere_population", donnees, wlm, true)
end

local tmp = p.donnees.valeur_recente(data)
if (tmp == nil) then
return p.outils.err_nodata("dernière_population", donnees, 7, true)
end

if (prm["type"] == "table") then
return tmp
end
if (prm["type"] == "date") then
return tmp[1]
end
if ((prm["type"] == nil) or (mw.text.trim(prm["type"]) == "")) then
return tmp[2]
end
return mw.language.getContentLanguage():formatNum(tmp[2])
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.derniere_population(frame)
local pframe = frame:getParent()
local param = {}
-- récupération des paramètre (nom et titre)
param["nom"] = p.outils.nettoie(frame.args[2] or pframe.args[2] or nil)
param["type"] = frame.args[1] or pframe.args[1] or nil
return p.derniere_population_m(param)
end

--[[
Retourne une phrase décrivant la variation de population de la commune
courante (ou "nom") ou un pictograme si "type" = "picto"
--]]
function p.variation_texte_m(prm)
local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("variation_texte", donnees, wlm, true)
end

local txt, sens = p.donnees.variation_texte(data)
if (txt == nil) then
return p.outils.err_nodata("variation_texte", donnees, 7, true)
end
if (prm["type"] ~= "picto") then
return txt
end
-- on crée le pictogramme
if (sens > 0) then
return "[[Fichier:Increase2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
elseif (sens < 0) then
return "[[Fichier:Decrease2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
else -- égal
return "[[fichier:steady.svg|10px|link=|class=noviewer|" .. txt .. "]]"
end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.variation_texte(frame)
local pframe = frame:getParent()
local param = {}
-- récupération des paramètre (nom et titre)
param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
param["type"] = frame.args["type"] or pframe.args["type"] or nil
return p.variation_texte_m(param)
end

--[[
Retourne la densité de la commune. Si "précision" indiquée utilise celle-ci,
sinon précision 1 par défaut
--]]

function p.densite_m(prm)
local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("densite", donnees, wlm, true)
end

local prc = 1
if (type(prm["précision"]) == "number") then
prc = prm["précision"]
end
if ((data[data["dernier"]]["pop"] == nil) or (data["superficie"] == nil)) then
return p.outils.err_nodata("densite", donnees, 7, true)
end

if (prm["format"] ~= nil) then
return mw.language.getContentLanguage():formatNum(
p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc))
else
return p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc)
end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.densite(frame)
local pframe = frame:getParent()
local param = {}
-- récupération des paramètre (nom et titre)
param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
param["précision"] = tonumber(frame.args["précision"] or pframe.args["précision"] or nil)
param["format"] = frame.args["format"] or pframe.args["format"] or nil
return p.densite_m(param)
end

--[[
Retourne la superficie de la commune.
--]]

function p.superficie_m(prm)
local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
local donnees = "Module:Données/" .. nom .. "/évolution population"

-- on charge les données associées à la commune
local data, wlm = p.donnees.charge_donnees(nom)
if (type(wlm) == "number") then
return p.outils.err_nodata("superficie", donnees, wlm, true)
end

return (data["superficie"])

end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.superficie(frame)
local pframe = frame:getParent()
local param = {}
-- récupération des paramètre (nom et titre)
param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
return p.superficie_m(param)
end
return p

Module:Population de France - Historique des versions

Theau 2 : 1 version importée

Infobox>JessydeVilly le 9 juillet 2020 à 19:51

Theau 2 : 1 version importée