Modulo:European and national party data

Questo è un modulo scritto in Lua. Le istruzioni che seguono sono contenute nella sottopagina Modulo:European and national party data/man (modifica · cronologia)
Sandbox: Modulo:European and national party data/sandbox (modifica · cronologia) · Sottopagine: lista · Test: Modulo:European and national party data/test (modifica · cronologia · esegui)
Uso
{{#invoke:European and national party data|main|<tipo_di_partito>|<tipo_di_dati>|<partito>|<instituzione>|parametri extra}}
Parametri
Parametro | Descrizione |
---|---|
1 | Il tipo di partito in esame; può essere:
Questo parametro è obbligatorio. |
2 | Il tipo di dati richiesti ed estratti da Wikidata, dal seguente elenco:
Questo parametro è obbligatorio. |
3 | Il nome dell'entità, dall'elenco seguente:
Questo parametro è facoltativo quando viene richiamato dalla pagina dell'entità in questione. Per i partiti europei si utilizzano le seguenti sigle:
Inoltre, sono coperte le seguenti alleanze politiche europee:
Inoltre, al posto dei partiti europei possono essere utilizzati quattro parametri speciali (quindi non quando
Note:
|
4 | Il nome dell'istituzione, tratto dal seguente elenco:
Note:
Questo parametro è obbligatorio quando il |
parametri extra | A seconda del tipo di dati richiesti, possono essere utilizzati anche i seguenti parametri extra:
Questi parametri sono opzionali. |
Template correlati
Il modulo è implementato direttamente da tre template:
- Template:Dati EUPP, che preimposta
|tipo_di_partito=entita_europea
; - Template:Dati partiti politici, che preseleziona
|tipo_di_partito=partito_nazionale
; e - Template:Seggi delle istituzioni dell'UE, che restituisce solo il numero di seggi delle istituzioni dell'UE (comprese tutte le camere basse o alte insieme).
Test cases
Il modulo ha due pagine di testcase:
- Modulo:European and national party data/testcases composition bar per il tipo di
dati barra_di_composizione_di_seggi
; e - Modulo:European and national party data/testcases per tutti gli altri tipi di dati.
Aggiornamento del modulo
Il modulo attinge i suoi dati da due fonti:
- Wikidata per tutti i dati restituiti dal modulo; e
- commons:Data:Mapping of national parties members of European parties to lower and upper houses.tab che mappa i partiti nazionali membri dei partiti politici europei e serve anche a collegare gli Stati membri (e quindi i partiti nazionali) alle loro camere basse e alte.
Per aggiornare i dati restituiti dal modulo, occorre andare alla pagina Wikidata dell'entità in questione (il link è spesso fornito come commento nell'infobox dell'articolo di Wikipedia) e modificare la proprietà pertinente, preferibilmente aggiungendo un nuovo valore e contrassegnandolo come preferito (invece di cancellare le informazioni obsolete).
Ecco alcune proprietà rilevanti per il modulo:
- numero di seggi in assemblea: P1410, con i seguenti qualificatori:
- organo legislativo: P194
- organo esecutivo (per la Commissione europea e il Consiglio europeo): P208
- legislatura (per il Parlamento europeo e la Commissione europea): P2937
- nome breve/acronimo: P1813
- colore/tripla di colori esadecimali RGB: P465
- paese: P17
- data di fondazione: P571
- membri individuali: P2124
- nome ufficiale: P1448
- gruppo parlamentare: P4100
- finanziamento pubblico: P12919
- sito web ufficiale: P856
Ove possibile, cercate di aggiungere
- un qualificatore di ora di inizio (P580) (e un corrispondente orario di fine (P582) nella voce obsoleta) o un qualificatore di punto nel tempo (P585), e
- una referenza, compresi i qualificatori URL di referenza (P854), titolo (P1476), recuperato (P813) e editore (P123).
L'aggiornamento di Wikidata garantisce la disponibilità di informazioni aggiornate e di provenienza non solo per questa Wiki, ma per tutte le versioni di Wikipedia e per altri servizi che attingono informazioni da Wikidata.
Traduzione del modulo
Per adattare il modulo a una nuova Wiki, seguire i seguenti passaggi:
- Creare due moduli per replicare i moduli sottostanti (il contenuto deve rimanere lo stesso della versione inglese):
- Creare i seguenti file e tradurli come necessario (tradurre solo le parti non in inglese, come indicato):
- Tradurre le documentazioni dei moduli e adattare gli esempi, se necessario, utilizzando i termini tradotti;
- Creare casi di prova, come quelli riportati di seguito, e adattare gli esempi, se necessario, utilizzando i termini tradotti:
- Modulo:European and national party data/testcases, e
- Modulo:European and national party data/testcases composition bar;
- Creare tre modelli per replicare quelli sottostanti:
- Template:Dati EUPP,
- Template:Dati partiti politici, e
- Template:Seggi delle istituzioni dell'UE;
- Tradurre le documentazioni dei modelli, sulla base delle documentazioni dei moduli, e adattare gli esempi come necessario utilizzando i termini tradotti;
- Aggiungere i due moduli nelle sezioni “Wikipedia” delle due pagine Wikidata pertinenti:
- Creare un argomento sulla consolidata pagina talk del modulo per adattare il contenuto del modulo comune (in particolare la sua funzione per le barre di composizione) alla nuova Wiki. Dopo l'adattamento, il modulo principale sarà sincronizzato per aggiornare i moduli in tutte le lingue del Wiki; ciò contribuisce a garantire che lo stesso modulo sia utilizzato in tutti i Wiki, il che è essenziale per mantenere aggiornate le sue funzioni.
Esempi
Tipo di dati seggi
Code | Resultato | Output |
---|---|---|
{{#invoke:European and national party data|main|entita_europea|seggi|PPE|EP}}
|
184 | numero di seggi del Partito Popolare Europeo al Parlamento europeo |
{{#invoke:European and national party data|main|entita_europea|seggi|PSE|CE|referenza=si}}
|
4[1] | numero di seggi del Partito dei Socialisti Europei nella Commissione europea, con referenza |
{{#invoke:European and national party data|main|entita_europea|seggi|ind|EUCO}}
|
5 | numero di seggi di politici indipendenti nel Consiglio europeo |
{{#invoke:European and national party data|main|entita_europea|seggi|ALDE|camera-bassa}}
|
417 | numero di seggi dell'Alleanza dei Democratici e dei Liberali per l'Europa nelle Camere basse degli Stati membri |
{{#invoke:European and national party data|main|entita_europea|seggi|PVE|camera-alta|referenza=si}}
|
50 | numero di seggi del Partito Verde Europeo nelle camere alte degli Stati membri, senza referenza (vedi tabella sopra) |
{{#invoke:European and national party data|main|entita_europea|seggi|Q208242|EC}}
|
11 | numero di seggi del Partito Popolare Europeo (chiamato con il suo qID Wikidata) nella Commissione Europea |
{{#invoke:European and national party data|main|entita_europea|seggi|Q208242|camera-alta}}
|
456 | numero di seggi del Partito Popolare Europeo (chiamato con il suo qID Wikidata) nelle camere alte degli stati membri |
{{#invoke:European and national party data|main|partito_nazionale|seggi|Q13564543|camera-bassa|referenza=si}}
|
18[2] | numero di seggi del NEOS austriaco (chiamato dal suo qID di Wikidata) nel Consiglio nazionale, con referenza |
{{#invoke:European and national party data|main|partito_nazionale|seggi|Q138198|camera-alta}}
|
76 | numero di seggi del Partito Socialista Operaio Spagnolo (chiamato dal suo qID di Wikidata) al Senato |
{{#invoke:European and national party data|main|partito_nazionale|seggi|Q49768|EP}}
|
14 | numero di seggi del Partito Socialdemocratico di Germania (chiamato con il suo qID Wikidata) nel Parlamento europeo |
{{#invoke:European and national party data|main|entita_europea|seggi|all|EP}}
|
642 | numero di seggi di tutti i partiti europei combinati nel Parlamento europeo |
{{#invoke:European and national party data|main|entita_europea|seggi|none|EP}}
|
78 | numero di seggi non occupati dai partiti europei al Parlamento europeo |
Tipo di dati quota_di_seggi
Code | Resultato | Output |
---|---|---|
{{#invoke:European and national party data|main|entita_europea|quota_di_seggi|PPE|PE|referenza=si}}
|
25.56 | quota di seggi del Partito Popolare Europeo al Parlamento europeo, con referenza |
{{#invoke:European and national party data|main|entita_europea|quota_di_seggi|ind|EUCO}}
|
18.52 | quota di seggi di politici indipendenti nel Consiglio europeo |
{{#invoke:European and national party data|main|entita_europea|quota_di_seggi|ALDE|camera-bassa}}
|
6.69 | quota di seggi dell'Alleanza dei Democratici e dei Liberali per l'Europa nelle Camere basse degli Stati membri |
{{#invoke:European and national party data|main|entita_europea|quota_di_seggi|Q208242|EC}}
|
40.74 | quota di seggi del Partito Popolare Europeo (chiamato con il suo qID Wikidata) nella Commissione Europea |
{{#invoke:European and national party data|main|partito_nazionale|quota_di_seggi|Q13564543|camera-bassa}}
|
9.84 | quota di seggi del NEOS austriaco (chiamato dal suo qID Wikidata) nel Consiglio Nazionale |
{{#invoke:European and national party data|main|partito_nazionale|quota_di_seggi|Q655611|camera-bassa|circoscrizione=61}}
|
4.92 | quota di seggi del partito belga Écolo (chiamato dal suo qID di Wikidata) nei seggi francofoni della Camera dei Rappresentanti |
{{#invoke:European and national party data|main|partito_nazionale|quota_di_seggi|Q49768|PE|referenza=si}}
|
14.58 | share of seggi of the Social Democratic Party of Germany (called by its Wikidata qID) in the European Parliament, with reference |
{{#invoke:European and national party data|main|entita_europea|quota_di_seggi|all|EP}}
|
89.17 | share of seggi of all European parties combined in the European Parliament |
Tipo di dati barra_di_composizione_di_seggi
Code | Resultato | Output |
---|---|---|
{{#invoke:European and national party data|main|entita_europea|barra_di_composizione_di_seggi|PPE|PE|referenza=si}}
|
184 / 720 [3]
|
barra di composizione dei seggi del Partito Popolare Europeo al Parlamento europeo, con referenza |
{{#invoke:European and national party data|main|entita_europea|barra_di_composizione_di_seggi|ind|EUCO|per-cento=si}}
|
5 / 27
|
barra di composizione dei seggi dei politici indipendenti nel Consiglio Europeo, con referenza |
{{#invoke:European and national party data|main|entita_europea|barra_di_composizione_di_seggi|ALDE|camera-bassa}}
|
417 / 6 229
|
barra di composizione dei seggi dell'Alleanza dei Democratici e dei Liberali per l'Europa nelle Camere basse degli Stati membri |
{{#invoke:European and national party data|main|entita_europea|barra_di_composizione_di_seggi|Q208242|CE|per-cento=si|referenza=si}}
|
11 / 27 [4]
|
barra di composizione dei seggi del Partito Popolare Europeo (chiamato dal suo qID di Wikidata) nella Commissione Europea, con referenza |
{{#invoke:European and national party data|main|partito_nazionale|barra_di_composizione_di_seggi|Q655611|camera-bassa|circoscrizione=61}}
|
3 / 61
|
composizione dei seggi del partito belga Écolo (chiamato dal suo qID di Wikidata) nei seggi francofoni della Camera dei Rappresentanti |
{{#invoke:European and national party data|main|partito_nazionale|barra_di_composizione_di_seggi|Q49768|PE|larghezza=80%|colore-di-sfondo=blue|bordo=green|colore-barra=red}}
|
14 / 96
|
barra di composizione dei seggi del Partito Socialdemocratico di Germania (chiamato con il suo qID di Wikidata) al Parlamento europeo, con i parametri speciali |
{{#invoke:European and national party data|main|entita_europea|barra_di_composizione_di_seggi|all|PE|larghezza=80%|colore-di-sfondo=#FFFF00|bordo=#008080|colore-barra=#A020F0}}
|
642 / 720
|
barra di composizione dei seggi di tutti i partiti europei combinati nel Parlamento europeo, con parametri speciali |
Altri tipi di dati
Code | Resultato | Output |
---|---|---|
{{#invoke:European and national party data|main|entita_europea|acronimo|PPE}}
|
PPE | acronimo del Partito Popolare Europeo |
{{#invoke:European and national party data|main|entita_europea|colore|PSE}}
|
#F0001C | colore del Partito dei Socialisti Europei |
{{#invoke:European and national party data|main|partito_nazionale|paese|Q1315362}}
|
Repubblica Ceca | paese di Levice (chiamato dal suo qID di Wikidata) |
{{#invoke:European and national party data|main|entita_europea|data_fondazione|PSE}}
|
10 novembre 1992 | data di fondazione del Partito dei socialisti europei |
{{#invoke:European and national party data|main|entita_europea|membri_individuali|PPE|referenza=si}}
|
25[5] | membri individuali del Partito Popolare Europeo, con referenza |
{{#invoke:European and national party data|main|entita_europea|data_membri_individuali|PPE}}
|
26 gennaio 2025 | data di membri individuali del Partito Popolare Europeo |
{{#invoke:European and national party data|main|entita_europea|data_membri_individuali|Volt}}
|
2024 | data di membri individuali del Volt |
{{#invoke:European and national party data|main|entita_europea|anno_membri_individuali|PPE}}
|
2025 | anno di membri individuali del Partito Popolare Europeo |
{{#invoke:European and national party data|main|entita_europea|anno_membri_individuali|Volt}}
|
2024 | anno di membri individuali del Volt |
{{#invoke:European and national party data|main|entita_europea|etichetta|ALDE}}
|
Alleanza dei Democratici e dei Liberali per l'Europa | etichetta dell'Alleanza dei Democratici e dei Liberali per l'Europa |
{{#invoke:European and national party data|main|entita_europea|nome_ufficiale|PVE}}
|
nome ufficiale del Partito Verde Europeo | |
{{#invoke:European and national party data|main|entita_europea|gruppo_parlamentare|ALE}}
|
Verdi/Alleanza Libera Europea | gruppo parlamentare dell'Alleanza libera europea |
{{#invoke:European and national party data|main|entita_europea|finanziamento_pubblico|PVE}}
|
171 460,56 euros | finanziamento pubblico del Partito Verde Europeo, con referenza |
{{#invoke:European and national party data|main|partito_nazionale|sito_web|Q667680}}
|
groenlinks.nl | sito web di GroenLinks dei Paesi Bassi |
{{#invoke:European and national party data|main|partito_nazionale|nome_ufficiale|Q22748|verboso=si}}
|
Error: {{European and national party data}}: nessun dato disponibile su Wikidata per P1448; see https://www.wikidata.org/wiki/Q22748 (aiuto) | nome ufficiale del partito Die PARTEI, che mostra il messaggio di errore verboso |
- ^ PES in the EU institutions, su pes.eu.
- ^ Sitzplan & Mandatsverteilung, su parlament.gv.at.
- ^ European People's Party, su appf.europa.eu, Autorità per i partiti politici europei e le fondazioni politiche europee.
- ^ Parties and partners, su epp.eu.
- ^ List of members as per Article 32(2) of Regulation 1141/2014 (English) (DOCX), su europarl.europa.eu.
require ('strict');
local get_args = require ('Module:Arguments').getArgs; -- function to fetch frame and parent frame arguments
local cfg = mw.loadData ('Module:European and national party data/config'); -- defines, configuration data, and i18n support
local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization
--[[==========================< S E C T I O N _ 1 : F U N C T I O N A L _ F U N C T I O N S >=======================
These are generic functions to accomplish specific, non-party-related tasks.
]]
--[[--------------------------< S U B S T I T U T E >----------------------------------------------------------
substitutes $1, $2, etc in <message> with data from <data_t>. Returns plain-text substituted string when
<data_t> not nil; returns <message> else.
]]
local function substitute (message, data_t)
return data_t and mw.message.newRawMessage (message, data_t):plain() or message;
end
--[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------
assembles an error message from template name, message text, help link, and error category.
]]
local function make_error_msg (msg, template_name, nocat)
local category;
local category_link = ((0 == namespace) and not nocat) and substitute ('[[Category:$1]]', {cfg.settings_t.err_category}) or '';
return substitute ('<span style="color:#d33">Error: {{$1}}: $2 ([[:Template:$1|$3]])</span>$4',
{
template_name or cfg.settings_t.template_name or frame:getParent():getTitle(), -- the template name without namespace
msg, -- the error message
cfg.settings_t.help, -- help wikilink display text
category_link -- link to error category (main namespace only)
})
end
--[[--------------------------< R O U N D >--------------------------------------------------------------------
return the rounded value of the arguments with two decimals
]]
local function round (n)
return math.floor(100 * n + 0.5) / 100 -- round argument to two decimals
end
--[[--------------------------< S T R I P _ U R L >--------------------------------------------------------------------
return the stripped down URL with a hyperlink
]]
local function strip_URL (URL)
local new_URL = URL;
local patterns_t = {'^%[%[(.*)%]%]', '^https://www.', '^http://www.', '^https://', '^http://', '^www.', '/$'}; -- valid <width> patterns
for i, pattern in ipairs (patterns_t) do -- loop through the patterns in <patterns_t>
new_URL = new_URL.gsub(new_URL, pattern, "");
end
return "[" .. URL .. " " .. new_URL .. "]";
end
--[[--------------------------< T R A N S L A T E >--------------------------------------------------------------------
translate a term based on the project language
]]
local function xlate (term)
if term then
--local new_term = string.gsub(term, " ", "_");
if 'en' == cfg.this_project_language then
return term;
elseif not cfg.xlate_t[cfg.this_project_language] then
return term;
elseif cfg.xlate_t[cfg.this_project_language][term] then
return cfg.xlate_t[cfg.this_project_language][term];
else
return term;
end
end
end
--[[--------------------------< T R A N S L A T E _ P A R A M >--------------------------------------------------------------------
translate a parameter based on the project language
]]
local function xlate_param (parameter)
if 'en' == cfg.this_project_language then
return parameter;
elseif not cfg.xlate_param_t[cfg.this_project_language] then
return parameter;
elseif cfg.xlate_param_t[cfg.this_project_language][parameter] then
return cfg.xlate_param_t[cfg.this_project_language][parameter];
else
return parameter;
end
end
--[[--------------------------< L O C A L _ P A R A M E T E R _ T O _ V A L U E _ O R _ B O O L E A N >--------------------------------------------------------------------
turns a given parameter into its local form and into a boolean
]]
local function local_parameter_to_value_or_boolean (frame, parameter, outcome) -- to test calls and functions, for verification purposes
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local localised_parameter = xlate_param (parameter); -- translate given parameter from English into local language
local argument = (args_t[tostring(localised_parameter)] and mw.ustring.lower(args_t[tostring(localised_parameter)])) or (args_t[parameter] and mw.ustring.lower(args_t[parameter])); -- get argument (in local language) matching parameter in local language
if outcome == 'boolean' then
if nil == argument then -- if no argument, return no
argument = false;
else
argument = xlate (argument); -- translate argument into English
argument = 'yes' == argument; -- turn argument into boolean
end
elseif nil ~= argument and argument:match ('^#') then
argument = argument.gsub(argument, "#", "#");
end
return argument;
end
--[[--------------------------< X L A T E _ W I K I D A T A >--------------------------------------------------------------------
call the {{wd}} or {{wikidata}} template based on language
arguments are as follows:
* data_requested: the type of data sought -- 'qualifier', 'property', 'references', 'label' -- compulsory
* qid: the Wikidata item on which data is sought -- e.g. Q208242 for the European People's Party -- not compulsory
* property_id: the property for which data is sought -- e.g. P1410 for number of seats in assembly -- compulsory
* qualifier_id: qualifier for property -- e.g. P194 for legislative body -- not compulsory
* value_of_qualifier: value of the qualifier -- e.g. P8889 for the European Parliament -- only compulsory if qualifier_id is provided
* reference: whether a reference should be displayed -- e.g. reference=yes to display the reference, anything else (preferably reference=no) otherwise; adding an "s" will display several references
* preferred: whether the preferred value should be displayed -- e.g. preferred=yes to display the preferred value, anything else (preferably preferred=no) otherwise
* raw: whether the qID should be displayed -- e.g. raw=yes to display the qID, anything else (preferably raw=no) otherwise
* linked: whether the value should be linked -- e.g. linked=yes to display the link, anything else (preferably linked=no) otherwise
]]
local function xlate_wikidata (data_requested, qid, property_id, qualifier_id, value_of_qualifier, reference, preferred, raw, linked, unit)
mw.logObject( {data_requested, qid, property_id, qualifier_id, value_of_qualifier, reference, preferred, raw, linked}, "xlate_wikidata()" )
local local_reference = (reference == 'reference=yes') and 'reference' or '';
if local_reference == '' and reference == 'references=yes' then local_reference = 'references' end;
local local_preferred = (preferred == 'preferred=yes') and 'preferred' or '';
local local_raw = (raw == 'raw=yes') and 'raw' or '';
local local_linked = (linked == 'linked=yes') and 'linked' or '';
local local_unit = (unit == 'unit=yes') and 'unit' or '';
local Wd = require('Module:European_and_national_party_data/Wd')
local wdargs = {local_reference, local_preferred, local_raw, local_linked, local_unit, property_id}
if qid then
table.insert(wdargs, 6, qid)
end
if '' ~= qualifier_id then
if '' ~= value_of_qualifier then
wdargs[qualifier_id] = value_of_qualifier;
else
table.insert(wdargs, qualifier_id)
end
end
mw.logObject( wdargs, "wdargs" )
return Wd['_' .. data_requested](wdargs);
end
--[[--------------------------< X L A T E _ C O M P O S I T I O N _ B A R >--------------------------------------------------------------------
call the {{composition bar}} template based on language
arguments are as follows:
* seats: the number of seats to be displayed;
* total_seats: the total number of seats of the institution in question;
* color: the color of the bar;
* width: the width of the bar;
* percentage: whether or not to display the percentage value;
* background_color: the background color of the bar;
* border: the color of the border;
]]
local function xlate_composition_bar (frame, seats, total_seats, color, width, percentage, background_color, border, num1, bar, num2)
if 'fr' == cfg.this_project_language then
return frame:expandTemplate ({title='Infobox Parti politique/Sièges', args = {seats, total_seats, ['hex'] = color, ['chiffres1'] = num1, ['barre'] = bar, ['chiffres2'] = num2}});
elseif 'it' == cfg.this_project_language then
return frame:expandTemplate ({title='Seggi', args = {seats, total_seats, ['c'] = color}});
elseif 'es' == cfg.this_project_language then
return frame:expandTemplate ({title='Composition bar', args = {seats, total_seats, ['hex'] = color}});
elseif 'pt' == cfg.this_project_language then
return frame:expandTemplate ({title='Info/Partido político/lugares', args = {seats, total_seats, color}});
elseif 'nl' == cfg.this_project_language then
local comp_bar_args_t = {
seats,
total_seats,
color,
width=width,
per=percentage,
['background-color'] = background_color,
border = border,
};
return frame:expandTemplate ({title='Percentagebalk', args = comp_bar_args_t});
else -- for all other languages the assumption is that the template is called composition bar
local comp_bar_args_t = {
seats,
total_seats,
color,
width=width,
per=percentage,
['background-color'] = background_color,
border = border,
};
return frame:expandTemplate ({title='Composition bar', args = comp_bar_args_t});
end
end
--[[==========================< S E C T I O N _ 2 : V A L I D A T I O N _ F U N C T I O N S >=======================
These are functions to ensure data validation and return error messages when relevant.
]]
--[[--------------------------< V A L I D A T E _ W I D T H >--------------------------------------------------
validates data format for the width parameter of composition bars; returns boolean true when valid; nil else
]]
local function validate_width (width)
local patterns_t = {'^%d+$', '^%d+px$', '^%d+%%$', '^%d+em$'}; -- valid <width> patterns
for i, pattern in ipairs (patterns_t) do -- loop through the patterns in <patterns_t>
if width:match (pattern) then -- is there a match?
return true; -- yes, done
end
end
end
--[[--------------------------< H A R M O N I S E _ H O U S E _ T Y P E >----------------------------------------------
harmonises house type input (for calls relating to lower and upper houses)
]]
local function harmonise_lower_upper_house_name (house_type)
if house_type == "LOWER-HOUSE" or house_type == "LOWER" or house_type == "MS-LOWER-HOUSE"then -- the three accepted formats for input
return "LOWER_HOUSE"; -- format actually used in the code
elseif house_type == "UPPER-HOUSE" or house_type == "UPPER" or house_type == "MS-UPPER-HOUSE" then -- the three accepted formats for input
return "UPPER_HOUSE"; -- format actually used in the code
else
return house_type;
end
end
--[[--------------------------< V A L I D A T E _ I N S T I T U T I O N >----------------------------
when institution parameter exists, checkes that it is correct; returns boolean true when valid; error message else
]]
local function validate_institution (institution, template_name)
if institution and not cfg.institutions_t[institution] and not cfg.national_institutions_t[institution] then -- if institution is present, it must be known
return make_error_msg (substitute (cfg.error_messages_t.unknown_inst, {institution}), template_name);
end
return true;
end
--[[==========================< S E C T I O N _ 3 : G E T _ F U N C T I O N S >=======================
These are functions to grab data from Wikidata
]]
--[[--------------------------< G E T _ D A T A >----------------------------------------------------------
general function to return data for the requested property for a party; <frame> required to expand {{wikidata}} template
]]
local function allpp_get_data (frame, party, property_id, option)
local template_name = frame:getParent():getTitle();
local args_t = get_args (frame);
local data = "";
local data_unit = "";
local reference = local_parameter_to_value_or_boolean (frame, 'reference', 'boolean'); -- check reference and make boolean
reference = (reference and option ~= "raw-noref") and 'references=yes' or ''; -- if reference is true, then the call will return a reference
local verbose = local_parameter_to_value_or_boolean (frame, 'verbose', 'boolean'); -- check verbose and make boolean
local raw = (option == "raw" or option == "raw-noref") and "raw=yes" or "raw=no"; -- check raw and format correctly
local linked = (option == "linked") and "linked=yes" or "linked=no"; -- check linked and format correctly
local unit = (option == "unit") and "unit=yes" or "unit=no"; -- check linked and format correctly
local party_qid = ""; -- init party_qid
if not party then -- party is required
return make_error_msg (substitute (cfg.error_messages_t.unknown_party, {party}), template_name);
elseif cfg.parties_t[party] then -- if party is a European party
party_qid = cfg.parties_t[party];
elseif cfg.alliances_t[party] then -- if party is a European alliance
party_qid = cfg.alliances_t[party];
elseif party:match ('^Q%d+$') then -- if party is a qID
party_qid = party;
elseif property_id == 'P465' and (party == "ALL" or party == "IND" or party == "NONE") then -- default colour for special parameters
return '#BBB';
elseif party ~= "THISPARTY" then -- error message if no party is provided
return make_error_msg (substitute (cfg.error_messages_t.unknown_party, {party}), template_name);
end
if not party then -- direct call when no party is specified
party_qid = "" -- This should not be needed since the function
end -- should error out above if no party specified.
if property_id == "label" then -- if the label of the Wikidata element is requested
data = xlate_wikidata ('label', party_qid, '', '', '', 'reference=no', 'preferred=no', raw, linked, unit);
elseif property_id == "individual members date" then -- special case
data = xlate_wikidata ('qualifier', party_qid, 'P2124', 'P585', '', 'reference=no', 'preferred=yes', raw, linked, unit);
elseif property_id == cfg.data_prop_t.public_funding then -- special case
data = tonumber(xlate_wikidata ('property', party_qid, property_id, '', '', '', '', 'raw=yes', '', ''));
data_unit = xlate_wikidata ('property', party_qid, property_id, '', '', '', '', '', '', 'unit=yes');
if nil ~= data then
if data > 1 then data_unit = data_unit .. 's' end;
else
data = '';
data_unit = '';
end
else -- for all other cases
data = xlate_wikidata ('property', party_qid, property_id, '', '', reference, 'preferred=no', raw, linked, unit);
end
if property_id == cfg.data_prop_t.colour then -- if no colour, then default colour
if '' == data then
data = '#BBB';
else
data = '#' .. data;
end
elseif property_id == cfg.data_prop_t.website then -- if no website, then empty string
if '' == data then
data = "";
else
data = strip_URL (data);
end
end
if '' == data and verbose then -- if verbose, then error message
return make_error_msg (substitute (cfg.error_messages_t.no_data, {party_qid, property_id}));
end
if property_id == cfg.data_prop_t.public_funding and '' ~= data then
return mw.getContentLanguage():formatNum(data) .. " " .. data_unit;
else
return data;
end
end
--[[--------------------------< H O U S E _ Q I D _ F R O M _ M E M B E R _ S T A T E >----------------------------------------------------------
return the qID of a house based on its name (lower house or upper house) and its member state; <frame> required to expand {{wikidata}} template
]]
local function house_qid_from_member_state_qid (house_type, member_state_qid)
local house_qid = "";
for row, _ in ipairs (cfg.ms_data_t) do -- loop on table with lower/upper houses per member state
if member_state_qid == cfg.ms_data_t[row].member_state_qid then
if house_type == "LOWER_HOUSE" then
house_qid = cfg.ms_data_t[row].lower_house_qid; -- get the lower house qid
elseif house_type == "UPPER_HOUSE" then
house_qid = cfg.ms_data_t[row].upper_house_qid; -- get the upper house qid
end
end
end
return house_qid;
end
--[[--------------------------< I N S T I T U T I O N _ S I Z E >----------------------------------------------------------
return the size of an institution; <frame> required to expand {{wikidata}} template
]]
local function institution_size (frame, institution)
local institution_size = xlate_wikidata ('property', cfg.institutions_t[institution], 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- get the institution size
if '' == institution_size then -- if no institution size
return make_error_msg (substitute (cfg.error_messages_t.unknown_inst, {institution}));
end
return institution_size;
end
--[[--------------------------< M E M B E R _ S T A T E _ D E L E G A T I O N _ S I Z E >----------------------------------------------------------
return the size of a member state's delegation in the European Parliament; <frame> required to expand {{wikidata}} template
]]
local function member_state_delegation_size (frame, member_state_qid)
local delegation_size = xlate_wikidata ('property', member_state_qid, 'P1410', 'P194', 'Q8889', 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- get the delegation size
if '' == delegation_size then -- if no delegation size
return make_error_msg (substitute (cfg.error_messages_t.not_member_state, {member_state_qid}));
end
return delegation_size;
end
--[[--------------------------< S I N G L E _ H O U S E _ S E A T S >------------------------------------------------
returns the number of seats in a given lower or upper house (identified by a row in the master table) from
wikidata. When <house_type> not recognized or when <ms_data_t> does not have 'that' house, returns 0
]]
local function single_house_seats (frame, row, house_type)
local house_qid;
if house_type == "LOWER_HOUSE" then
house_qid = cfg.ms_data_t[row].lower_house_qid; -- get the lower house qid
elseif house_type == "UPPER_HOUSE" then
house_qid = cfg.ms_data_t[row].upper_house_qid; -- get the upper house qid
end
return house_qid and xlate_wikidata ('property', house_qid, 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no') or 0; -- house_qid is nil when no upper or lower house
end
--[[--------------------------< T O T A L _ H O U S E _ S E A T S >------------------------------------------------
returns the total number of seats of all lower or upper houses in all member states.
]]
local function total_house_seats (frame, house_type)
local sum_seats = 0; -- init sum of seats of European party's member parties in house_type
for row, _ in ipairs (cfg.ms_data_t) do -- for all member states
sum_seats = sum_seats + single_house_seats (frame, row, house_type); -- increase sum_seats
end
return sum_seats;
end
--[[--------------------------< A L L P P _ S E A T S _ R E F >---------------------------------------------------------------
return the reference for a seat claim; <frame> required to expand {{wikidata}} template
]]
local function allpp_seats_ref (frame, party, institution)
local args_t = get_args (frame);
local party_type = args_t[1] and mw.ustring.lower(args_t[1]); -- force to lower case
party_type = xlate (party_type);
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then
if party_type == 'european_entity' then
return '';
elseif party_type == 'national_party' then
if party == "THISPARTY" then
local member_state_qid = allpp_get_data (frame, mw.wikibase.getEntityIdForCurrentPage(), cfg.data_prop_t.country, 'raw-noref');
local house_qid = house_qid_from_member_state_qid (institution, member_state_qid)
return xlate_wikidata ('references', '', 'P1410', 'P194', house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif party:match ('^Q%d+$') then
local member_state_qid = allpp_get_data (frame, party, cfg.data_prop_t.country, 'raw-noref');
local house_qid = house_qid_from_member_state_qid (institution, member_state_qid)
return xlate_wikidata ('references', party, 'P1410', 'P194', house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
end
end
elseif institution == 'EC' or institution == 'EUCO' then
if party == "THISPARTY" then
return xlate_wikidata ('references', '', 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif cfg.parties_t[party] then
return xlate_wikidata ('references', cfg.parties_t[party], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif cfg.alliances_t[party] then
return xlate_wikidata ('references', cfg.alliances_t[party], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif party:match ('^Q%d+$') then
return xlate_wikidata ('references', party, 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
end
else
if party == "THISPARTY" then
return xlate_wikidata ('references', '', 'P1410', 'P194', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif cfg.parties_t[party] then
return xlate_wikidata ('references', cfg.parties_t[party], 'P1410', 'P194', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif cfg.alliances_t[party] then
return xlate_wikidata ('references', cfg.alliances_t[party], 'P1410', 'P194', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif party:match ('^Q%d+$') then
return xlate_wikidata ('references', party, 'P1410', 'P194', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
end
end
end
local function allpp_get_seats_ref_qid (frame, institution_qid)
return xlate_wikidata ('references', '', 'P1410', 'P194', institution_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
end
--[[==========================< S E C T I O N _ 4 : S U M _ F U N C T I O N S >=======================
These functions are the ones providing seat numbers for European or national parties, in European institutions or national lower/upper houses
* functions starting with eupp apply to European parties;
* functions starting with npp apply to national political parties; and
* functions starting with allpp apply to all political parties.
]]
--[[--------------------------< A L L P P _ M A K E _ S H A R E _ I N _ E U _ I N S T I T U T I O N S >--------------------------------------------------------------
return the share of a party's seats relative to the total size of a given institution listed in <cfg.parties_t> or <cfg.alliances_t> (so not including lower and upper houses)
<frame> required to expand {{wikidata}} template
Note: P1342 is the property "number of seats", used to record an institution's number of seats
]]
local function allpp_make_share_in_eu_institutions (frame, party_seats, institution)
local args_t = get_args (frame);
local party_type = args_t[1] and mw.ustring.lower(args_t[1]); -- force to lower case
local party = args_t[3] and mw.ustring.upper(args_t[3]); -- force to upper case
local constituency = local_parameter_to_value_or_boolean (frame, 'constituency'); -- argument overriding the house's number of seats
party_type = xlate (party_type);
party = xlate (party);
if constituency then
return tonumber (party_seats) and round (100 * party_seats / constituency) or party_seats;
elseif party_type == "national_party" and institution == "EP" then
local member_state_qid = allpp_get_data (frame, party, cfg.data_prop_t.country, 'raw-noref');
return tonumber (party_seats) and round (100 * party_seats / member_state_delegation_size (frame, member_state_qid)) or party_seats;
else
return tonumber (party_seats) and round (100 * party_seats / xlate_wikidata ('property', cfg.institutions_t[institution], 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no')) or party_seats;
end
end
--[[--------------------------< A L L P P _ S E A T S _ I N _ E U _ I N S T I T U T I O N S >------------------------------------------------------------------
return the number of seats occupied by a political party in an <institution> listed in <cfg.parties_t> or in <cfg.alliances_t> (so not including lower and upper houses). <body_prop> is the wikidata property:
P194: legislative body
P208: executive body
<frame> required to expand {{wikidata}} template
Note: P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
]]
local function allpp_seats_in_eu_institutions (frame, party, institution, body_prop)
local args_input_t = get_args (frame);
local verbose = local_parameter_to_value_or_boolean (frame, 'verbose', 'boolean'); -- check verbose and make boolean
local args_t = {};
local retval = "";
if party == "THISPARTY" then -- flag used when module is called from the page of a European party; less expensive
retval = xlate_wikidata ('property', '', 'P1410', body_prop, cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- init some of the {{wikidata}} parameters with THISPARTY (only when called from the page of a European party)
elseif cfg.alliances_t[party] then
retval = xlate_wikidata ('property', cfg.alliances_t[party], 'P1410', body_prop, cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- init some of the {{wikidata}} parameters
elseif cfg.parties_t[party] then
retval = xlate_wikidata ('property', cfg.parties_t[party], 'P1410', body_prop, cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- init some of the {{wikidata}} parameters
elseif party:match ('^Q%d+$') then
retval = xlate_wikidata ('property', party, 'P1410', body_prop, cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- init some of the {{wikidata}} parameters
end
if '' == retval then -- {{wikidata}} returns empty string when <party> not known to <institution>
if party == "THISPARTY" then -- specific error message if the module was called with THISPARTY from the wrong page
return "";
elseif not party then
return make_error_msg (substitute (cfg.error_messages_t.party_req_share)), true;
else
return make_error_msg (substitute (cfg.error_messages_t.inst_unknown_party, {institution, party})), true;
end
end
return retval;
end
--[[--------------------------< E U P P _ S U M _ S E A T S _ I N _ E U _ I N S T I T U T I O N S >------------------------------------------------------------------------
return the sum of seats for all European parties combined in an <institution> listed in <cfg.parties_t> (so not including lower and upper houses). <body_prop> is the wikidata
property:
P194: legislative body
P208: executive body
<frame> required to expand {{wikidata}} template
Note: P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
]]
local function eupp_sum_seats_in_eu_institutions (frame, institution, body_prop)
local sum = 0; -- init
for _, qid in pairs (cfg.parties_t) do -- loop through all parties in <cfg.parties_t>
local local_qid = qid; -- set the last {{wikidata}} parameter
sum = sum + xlate_wikidata ('property', local_qid, 'P1410', body_prop, cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- expand and tally
end
return sum;
end
--[[--------------------------< E U P P _ S E A T S _ I N _ E U _ I N S T I T U T I O N S >--------------------------------------------------------------------
return a number of seats of a European party (or special parameter) in an <institution> (so not including lower and upper houses).
<frame> required to expand {{wikidata}} template
Note:
* P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
* P1342 is the property "number of seats", used to record an institution's number of seats
* P208 is the property "executive body"
* P194 is the property "legislative body"
]]
local function eupp_seats_in_eu_institutions (frame, party, institution)
if party == "IND" and institution == "EUCO" then -- special case of independent politicians on European Council
return xlate_wikidata ('property', cfg.misc_parties_t['IND'], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
elseif party == "NONE" then -- returns seats not occupied by European parties
local retval = xlate_wikidata ('property', cfg.institutions_t[institution], 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no'); -- get number of seats in the institution
if institution == "EUCO" then -- if EUCO, use P208 and separate case to account for independent politicians
local ind = xlate_wikidata ('property', cfg.misc_parties_t['IND'], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
return retval - (eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]) + ind);
else -- COR, EC, EP
return retval - eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]);
end
elseif party == "ALL" then -- returns seats occupied by all European parties combined
return eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]);
elseif party:match ('^Q%d+$') then
local party_name = cfg.rev_parties_t[party] or cfg.rev_alliances_t[party];
return allpp_seats_in_eu_institutions (frame, party_name, institution, cfg.body_prop_t[institution]);
else -- returns the number of seats occupied by one party in one institution
return allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]);
end
end
--[[--------------------------< E U P P _ S E A T _ S H A R E _ I N _ E U _ I N S T I T U T I O N S >--------------------------------------------------------
return a share of seats of a European party (or special parameter) in an <institution> (so not including lower and upper houses).
<frame> required to expand {{wikidata}} template
Note:
* P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
* P1342 is the property "number of seats", used to record an institution's number of seats
* P208 is the property "executive body"
* P194 is the property "legislative body"
]]
local function eupp_seat_share_in_eu_institutions (frame, party, institution)
if party == "IND" and institution == "EUCO" then -- special case of independent politicians on European Council
return allpp_make_share_in_eu_institutions (frame, xlate_wikidata ('property', cfg.misc_parties_t['IND'], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no'), institution);
elseif party == "NONE" then -- returns seats not occupied by European parties
local retval = xlate_wikidata ('property', cfg.institutions_t[institution], 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
if institution == "EUCO" then -- if EUCO, use P208 and separate case to account for independent politicians
local ind = xlate_wikidata ('property', cfg.misc_parties_t['IND'], 'P1410', 'P208', cfg.institutions_t[institution], 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
return allpp_make_share_in_eu_institutions (frame, retval - (eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]) + ind), institution);
else -- for COR, EC, EP
return allpp_make_share_in_eu_institutions (frame, retval - eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]), institution);
end
elseif party == "ALL" then -- returns seats occupied by all European parties combined
return allpp_make_share_in_eu_institutions (frame, eupp_sum_seats_in_eu_institutions (frame, institution, cfg.body_prop_t[institution]), institution);
elseif party:match ('^Q%d+$') then
party = cfg.rev_parties_t[party] or cfg.rev_alliances_t[party];
return allpp_make_share_in_eu_institutions (frame, allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]), institution);
else -- returns the number of seats occupied by one party in one institution
return allpp_make_share_in_eu_institutions (frame, allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]), institution);
end
end
--[[--------------------------< N P P _ S E A T S _ P E R _ R O W >------------------------------
returns the number of seats occupied by a given party (identified by a given row in the master table) in the
lower or upper house of its member state from wikidata. When <house_type> not recognized or when <tab_data_t>
does not have 'that' house, returns 0
]]
local function npp_seats_per_row (frame, row, house_type)
local house_qid = "";
local national_party_qid = cfg.tab_data_t[row].national_party_qid;
if house_type == "LOWER_HOUSE" then
house_qid = cfg.tab_data_t[row].lower_house_qid; -- get the qID of a lower house
elseif house_type == "UPPER_HOUSE" then
house_qid = cfg.tab_data_t[row].upper_house_qid; -- get the qID of an upper house
end
return house_qid and xlate_wikidata ('property', national_party_qid, 'P1410', 'P194', house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no') or 0;
end
--[[--------------------------< E U P P _ S E A T S _ I N _ N A T I O N A L _ I N S T I T U T I O N S >------------------------------
returns the sum of seats occupied by all national parties members of a given European party in the lower or upper house of its member state.
]]
local function eupp_seats_in_national_institutions (frame, party, house_type)
local sum_seats = 0; -- init sum of seats of European party's member parties in house_type
for row, _ in ipairs (cfg.tab_data_t) do
if party == "THISPARTY" then -- if called from the page of a European party
local thisparty_qid = mw.wikibase.getEntityIdForCurrentPage(); -- get party qiD
if thisparty_qid == cfg.tab_data_t[row]['european_party_qid'] then
sum_seats = sum_seats + npp_seats_per_row (frame, row, house_type); -- increase sum_seats
end
elseif party == "ALL" or party == "NONE" then -- not accepted parameters
return make_error_msg (substitute (cfg.error_messages_t.all_none_unavailable, {party}));
elseif party == "IND" then -- not accepted parameter
return make_error_msg (substitute (cfg.error_messages_t.ind_only_euco));
elseif party:match ('^Q%d+$') then -- if party name is a qID
if party == cfg.tab_data_t[row]['european_party_qid'] then
sum_seats = sum_seats + npp_seats_per_row (frame, row, house_type); -- increase sum_seats
end
else --for any other party name (already approved via party_type validation)
if party == cfg.tab_data_t[row]['european_party'] then
sum_seats = sum_seats + npp_seats_per_row (frame, row, house_type); -- increase sum_seats
end
end
end
return sum_seats;
end
--[[--------------------------< E U P P _ S E A T _ S H A R E _ I N _ N A T I O N A L _ I N S T I T U T I O N S >--------------------------------------------------------
return a share of seats occupied by one or more entities listed in <cfg.parties_t> or <cfg.alliances_t>, or by none of them, in an <institution> (so not including lower and upper houses).
<frame> required to expand {{wikidata}} template
]]
local function eupp_seat_share_in_national_institutions (frame, party, institution)
return round (100 * eupp_seats_in_national_institutions (frame, party, institution) / total_house_seats (frame, institution)); -- return share of seats by calling seat_share()
end
--[[--------------------------< N P P _ S E A T S _ A N D _ S E A T _ S H A R E _ I N _ N A T I O N A L _ I N S T I T U T I O N S >------------------------------------------------
returns the sum or share of seats occupied by a national party in the lower or upper house of its member state.
]]
local function npp_seats_and_seat_share_in_national_institutions (frame, party, house_type, data)
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local party_qid = "";
local constituency = local_parameter_to_value_or_boolean (frame, 'constituency'); -- argument overriding the house's number of seats
if party == "THISPARTY" then
party_qid = mw.wikibase.getEntityIdForCurrentPage();
elseif party:match ('^Q%d+$') then
party_qid = party;
end
--[=[ data validation for party_qid ]=]
if party_qid == '' then
return make_error_msg (cfg.error_messages_t.no_qid, template_name); -- yep, abandon with error message
end
--[=[ get house_qid from party qid and house_seats ]=]
local member_state_qid = allpp_get_data (frame, party_qid, cfg.data_prop_t.country, 'raw-noref');
local house_qid = house_qid_from_member_state_qid (house_type, member_state_qid);
local npp_seats = house_qid and xlate_wikidata ('property', party_qid, 'P1410', 'P194', house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no') or 0;
local house_seats = house_qid and xlate_wikidata ('property', house_qid, 'P1342', '', '', 'reference=no', 'preferred=no', 'raw=no', 'linked=no') or 0;
if data == "seats" then
return npp_seats;
elseif data == "seat share" then
if constituency then
return round (100 * npp_seats / constituency);
else
return round (100 * npp_seats / house_seats);
end
elseif data == "house seats" then
return house_seats;
end
end
--[[--------------------------< A L L P P _ C O M P O S I T I O N _ B A R >------------------------------------------------
this function does whatever it is that {{composition bar}} does
implements {{EUPP composition bar}}
{{EUPP composition bar|<institution>|<party>|width=<width>|percent=yes|reference=yes|bar-color=<color>|background-color=<color>|border=<color>}}
]]
local function allpp_composition_bar (frame, party, institution, party_type)
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local verbose = local_parameter_to_value_or_boolean (frame, 'verbose', 'boolean'); -- check verbose and make boolean
local percentage = local_parameter_to_value_or_boolean (frame, 'percent', 'boolean'); -- check percent and make boolean
local reference = local_parameter_to_value_or_boolean (frame, 'reference', 'boolean'); -- check reference and make boolean
local width = local_parameter_to_value_or_boolean (frame, 'width'); -- must be a number, or number with unit suffix: 'px', '%', 'em'; whitespace not allowed
local constituency = local_parameter_to_value_or_boolean (frame, 'constituency'); -- argument overriding the house's number of seats
local institution_seats = 0;
local party_seats = 0;
local background_color = local_parameter_to_value_or_boolean (frame, 'background-color');
local border = local_parameter_to_value_or_boolean (frame, 'border');
local num1 = local_parameter_to_value_or_boolean (frame, 'num1');
local bar = local_parameter_to_value_or_boolean (frame, 'bar');
local num2 = local_parameter_to_value_or_boolean (frame, 'num2');
if width and not validate_width (width) then
return make_error_msg (substitute (cfg.error_messages_t.parameter_invalid, {width}), template_name); -- yep, abandon with error message
end
--[=[ prepare arguments for composition bar ]=]
if party_type == "european_entity" then
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then
party_seats = eupp_seats_in_national_institutions (frame, party, institution); -- get sum of seats occupied by members of a European party
institution_seats = total_house_seats(frame, institution); -- get total seats of lower or upper houses
else
party_seats = eupp_seats_in_eu_institutions (frame, party, institution); -- get total seats in <institution> occupied by <party>
institution_seats = institution_size (frame, institution); -- get total seats in <institution>
end
elseif party_type == "national_party" then
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then
party_seats = npp_seats_and_seat_share_in_national_institutions (frame, party, institution, "seats");
institution_seats = constituency or npp_seats_and_seat_share_in_national_institutions (frame, party, institution, "house seats")
elseif institution == "EP" then
local member_state_qid = allpp_get_data (frame, party, cfg.data_prop_t.country, 'raw-noref');
local has_error;
party_seats, has_error = allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]);
if has_error then
return party_seats; -- <party_seats> has an error message
end
institution_seats = constituency or member_state_delegation_size (frame, member_state_qid); -- get total seats in <institution>
else
local has_error;
party_seats, has_error = allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]);
if has_error then
return party_seats; -- <party_seats> has an error message
end
institution_seats = constituency or institution_size (frame, institution); -- get total seats in <institution>
end
end
local color = local_parameter_to_value_or_boolean (frame, 'bar-color') or allpp_get_data (frame, party, cfg.data_prop_t.colour); -- get color associated with <party>; |bar-color= overrides wikidata
if '' == party_seats or ''== institution_seats then
if verbose then
return make_error_msg (substitute (cfg.error_messages_t.no_data_short));
else
return "";
end
elseif party_type == "european_entity" and (institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE") then
return xlate_composition_bar (frame, party_seats, institution_seats, color, width, percentage, background_color, border, num1, bar, num2);
else
return xlate_composition_bar (frame, party_seats, institution_seats, color, width, percentage, background_color, border, num1, bar, num2) .. ((reference and allpp_seats_ref (frame, party, institution)) or '');
end
end
--[[==========================< S E C T I O N _ 5 : M A I N _ & _ T E S T _ F U N C T I O N S >=======================]]
--[[--------------------------< M A I N >----------------------------------------------------------------------
implements {{EUPP data}} and {{political party data}} (the templates hard-code the <party_type> information)
carries out input error detection, reporting, and function dispatching
Module called by as follows:
{{EUPP data|<data_type>|<institution>|<party>|width=<width>|percent=yes|reference=yes|bar-color=<color>|background-color=<color>|border=<color>}}
{{Political party data|<data_type>|<institution>|<party>|width=<width>|percent=yes|reference=yes|bar-color=<color>|background-color=<color>|border=<color>}}
where <data_type> is:
* seats
* seat share
* seat composition bar
* colour
* individual members
* acronym
* country
* name
* public funding
* website
* foundation date
]]
local function main(frame)
local template_name = frame:getParent():getTitle()
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local party_type = args_t[1] and mw.ustring.lower(args_t[1]); -- force to lower case
local data_type = args_t[2] and mw.ustring.lower(args_t[2]); -- force to lower case
local party = args_t[3] and mw.ustring.upper(args_t[3]); -- force to upper case
local institution = args_t[4] and mw.ustring.upper(args_t[4]); -- force to upper case
local party_qid = "";
local ref = "";
--[=[ translate arguments ]=]
party_type = xlate (party_type);
data_type = xlate (data_type);
party = xlate (party);
institution = xlate (institution);
--[=[ prepare arguments ]=]
local reference = local_parameter_to_value_or_boolean (frame, 'reference', 'boolean'); -- make a boolean
institution = harmonise_lower_upper_house_name (institution); -- "ms-lower-house" and "lower" are turned to "lower_house" (same for upper house)
party = harmonise_lower_upper_house_name (party); -- in case institution is entered as party
if cfg.institutions_t[party] or party == "LOWER_HOUSE" or party == "UPPER_HOUSE" then -- if the name of the party is actually the institution, then party is "thisparty"
institution = party;
party = "THISPARTY";
end
if not party then -- if party is missing, then it is "thisparty"
party = "THISPARTY";
end
--[=[ data validation party type ]=]
if party_type == "european_entity" and not (cfg.parties_t[party] or cfg.alliances_t[party] or cfg.rev_parties_t[party] or cfg.rev_alliances_t[party] or party == "ALL" or party == "NONE" or party == "IND" or party == "THISPARTY") then
return make_error_msg (substitute (cfg.error_messages_t.not_valid_eupp_parameter, {party}), template_name);
elseif party_type == "european_entity" and party == "THISPARTY" and not (cfg.rev_parties_t[mw.wikibase.getEntityIdForCurrentPage()] or cfg.rev_alliances_t[mw.wikibase.getEntityIdForCurrentPage()]) then
return make_error_msg (substitute (cfg.error_messages_t.thisparty), template_name);
elseif party_type == "national_party" and (cfg.parties_t[party] or cfg.alliances_t[party] or cfg.rev_parties_t[party] or cfg.rev_alliances_t[party] or party == "ALL" or party == "NONE" or party == "IND" or (party == "THISPARTY" and not mw.wikibase.getEntityIdForCurrentPage())) then
return make_error_msg (substitute (cfg.error_messages_t.not_valid_npp, {party}), template_name);
end
--[=[ data validation institution ]=]
local is_valid = false;
is_valid = validate_institution (institution, template_name);
if true ~= is_valid then -- boolean true when valid; error message else
return is_valid; -- yep, abandon with error message
end
--[=[ function dispatching ]=]
--[=[ send to seat functions ]=]
if data_type == "seats" then -- we look for a seat number
if not institution then -- institution is required
return make_error_msg (cfg.error_messages_t.missing_inst, template_name);
end
if true == reference then
ref = allpp_seats_ref (frame, party, institution);
end
if party_type == "european_entity" then -- the party is a European party or European alliance (specified by the calling template, not by the user)
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then -- we look for seats aross lower or upper houses
return eupp_seats_in_national_institutions (frame, party, institution) .. ref; -- return the number of seats by calling eupp_seats_in_national_institutions
else -- we look for seats in a European institution
return eupp_seats_in_eu_institutions (frame, party, institution) .. ref; -- return the number of seats by calling eupp_seats_in_eu_institutions
end
elseif party_type == "national_party" then -- the party is a national party
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then -- we look for seats in a lower or upper house
return npp_seats_and_seat_share_in_national_institutions (frame, party, institution, "seats") .. ref; -- return the number of seats by calling ...
else -- we look for seats in a European institution
return allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]) .. ref; -- return the number of seats by calling allpp_seats_in_eu_institutions
end
else
return make_error_msg (substitute (cfg.error_messages_t.unknown_party_type, {party_type}), template_name);
end
--[=[ send to seat share functions ]=]
elseif data_type == "seat share" then
if not institution then -- institution is required
return make_error_msg (cfg.error_messages_t.missing_inst, template_name);
end
if party_type == "european_entity" then
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then
return eupp_seat_share_in_national_institutions (frame, party, institution);
else
return eupp_seat_share_in_eu_institutions (frame, party, institution);
end
elseif party_type == "national_party" then
if institution == "LOWER_HOUSE" or institution == "UPPER_HOUSE" then
return npp_seats_and_seat_share_in_national_institutions (frame, party, institution, "seat share");
else
return allpp_make_share_in_eu_institutions (frame, allpp_seats_in_eu_institutions (frame, party, institution, cfg.body_prop_t[institution]), institution); -- return share of seats by calling seat_share()
end
else
return make_error_msg (substitute (cfg.error_messages_t.unknown_party_type, {party_type}), template_name);
end
--[=[ send to composition bar functions ]=]
elseif data_type == "seat composition bar" then
if not institution then -- institution is required
return make_error_msg (cfg.error_messages_t.missing_inst, template_name);
end
return allpp_composition_bar (frame, party, institution, party_type);
--[=[ send to get_data functions ]=]
elseif data_type == "acronym" then
return allpp_get_data (frame, party, cfg.data_prop_t.acronym);
elseif data_type == "color" then
return allpp_get_data (frame, party, cfg.data_prop_t.colour);
elseif data_type == "country" then
return allpp_get_data (frame, party, cfg.data_prop_t.country, 'linked');
elseif data_type == "foundation date" then
return allpp_get_data (frame, party, cfg.data_prop_t.foundation_date);
elseif data_type == "foundation year" then
return mw.getContentLanguage():formatDate("Y",allpp_get_data (frame, party, cfg.data_prop_t.foundation_date, 'raw'));
elseif data_type == "individual members" then
return allpp_get_data (frame, party, cfg.data_prop_t.individual_members);
elseif data_type == "individual members date" then
return allpp_get_data (frame, party, 'individual members date');
elseif data_type == "individual members year" then
return mw.getContentLanguage():formatDate("Y",allpp_get_data (frame, party, 'individual members date', 'raw'));
elseif data_type == "label" then
return allpp_get_data (frame, party, 'label');
elseif data_type == "official name" then
return allpp_get_data (frame, party, cfg.data_prop_t.official_name);
elseif data_type == "parliamentary group" then
return allpp_get_data (frame, party, cfg.data_prop_t.parliamentary_group, 'linked');
elseif data_type == "public funding" then
return allpp_get_data (frame, party, cfg.data_prop_t.public_funding);
elseif data_type == "website" then
return allpp_get_data (frame, party, cfg.data_prop_t.website);
else
return make_error_msg (substitute (cfg.error_messages_t.unknown_data_type, {data_type}), template_name);
end
end
--[[--------------------------< E U _ I N S T I T U T I O N _ S E A T S >----------------------------------------------------------------------
]]
local function eu_institution_seats (frame)
local template_name = frame:getParent():getTitle()
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local institution = args_t[1] and mw.ustring.upper(args_t[1]); -- force to upper case
institution = xlate (institution);
institution = harmonise_lower_upper_house_name (institution); -- "ms-lower-house" and "lower" are turned to "lower_house" (same for upper house)
--[=[ data validation institution ]=]
local is_valid = false;
is_valid = validate_institution (institution, template_name);
if true ~= is_valid then -- boolean true when valid; error message else
return is_valid; -- yep, abandon with error message
end
--[=[ return value ]=]
if institution == 'LOWER_HOUSE' or institution == 'UPPER_HOUSE' then
return total_house_seats (frame, institution);
else
return institution_size (frame, institution);
end
end
--[[--------------------------< T E S T _ W I K I D A T A _ E N T R I E S >----------------------------------------------------------------------
]]
local function test_wikidata_entries (frame) -- to test calls and functions, for verification purposes
local wikidata_error = "Wikidata entries error(s):";
for row, _ in ipairs (cfg.tab_data_t) do
local national_party_qid = cfg.tab_data_t[row].national_party_qid;
local national_party_name = "";
if not cfg.tab_data_t[row].national_party then
national_party_name = cfg.tab_data_t[row].national_party_english;
else
national_party_name = cfg.tab_data_t[row].national_party;
end
local lower_house_qid = cfg.tab_data_t[row].lower_house_qid;
local lower_house_name = cfg.tab_data_t[row].lower_house;
local upper_house_qid = cfg.tab_data_t[row].upper_house_qid;
local upper_house_name = cfg.tab_data_t[row].upper_house;
local retval_lower = xlate_wikidata ('property', national_party_qid, 'P1410', 'P194', lower_house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
local retval_upper = xlate_wikidata ('property', national_party_qid, 'P1410', 'P194', upper_house_qid, 'reference=no', 'preferred=no', 'raw=no', 'linked=no');
if '' == retval_lower then
wikidata_error = wikidata_error .. " [https://www.wikidata.org/wiki/" .. national_party_qid .. " " .. national_party_name .. "] (" .. lower_house_name .. ")";
end
if '' == retval_upper then
wikidata_error = wikidata_error .. " [https://www.wikidata.org/wiki/" .. national_party_qid .. " " .. national_party_name .. "] (" .. upper_house_name .. ")";
end
end
if wikidata_error == "Wikidata entries error(s):" then
wikidata_error = "Wikidata entries: all good!";
end
return wikidata_error;
end
--[[--------------------------< T E S T >----------------------------------------------------------------------
]]
local function test (frame) -- to test calls and functions, for verification purposes
local args_t = get_args (frame); -- get arguments; empty string or whitespace positional parameters set to nil
local parameter = args_t['parameter'] and mw.ustring.lower(args_t['parameter']); -- force to lower case
local outcome = args_t['outcome'] and mw.ustring.lower(args_t['outcome']); -- force to lower case
local localised_parameter = xlate_param (parameter); -- translate given parameter from English into local language
local argument = (args_t[tostring(localised_parameter)] and mw.ustring.lower(args_t[tostring(localised_parameter)])) or (args_t[parameter] and mw.ustring.lower(args_t[parameter])); -- get argument (in local language) matching parameter in local language
if outcome == 'boolean' then
if nil == argument then -- if no argument, return no
argument = false;
else
argument = xlate (argument); -- translate argument into English
argument = 'yes' == argument; -- turn argument into boolean
end
elseif argument:match ('^#') then
argument = argument.gsub(argument, "#", "#");
end
return argument;
--return "parameter: " .. parameter .. " - outcome: " .. tostring(outcome) .. " - localised parameter: " .. localised_parameter .. " - argument: " .. tostring(argument);
end
local function test2 (frame)
return cfg.this_project_language;
end
--[[--------------------------< E X P O R T S >----------------------------------------------------------------
]]
return {
main = main,
eu_institution_seats = eu_institution_seats,
test = test,
test2 = test2,
test_wikidata_entries = test_wikidata_entries,
-- xlate_wikidata = xlate_wikidata
}