Modul:Lehensabfrage: Unterschied zwischen den Versionen

Aus KoschWiki
Zur Navigation springen Zur Suche springen
SyncBot (D | B)
K (Schützte „Modul:Lehensabfrage“: Automatisch gesperrt. ([Verschieben=Nur Administratoren erlauben] (unbeschränkt) [Bearbeiten=Nur Administratoren erlauben] (unbeschränkt)) [kaskadierend])
SyncBot (D | B)
K (SyncBot)
 
(4 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
local p = {}
local p = {}


function robusttrim(s)
require("Modul:Hilfsfunktionen")
if s==nil then return '' end
require("Modul:Text")
local p=string.gsub(s,'%[%[SMW::on%]%]','')
 
p=string.gsub(p,'%[%[SMW::off%]%]','')
function holeLehenDetails(lehen)
return mw.text.trim(p)
if lehen=='' then return {} end
local s='[['..lehen..']]'
local details=mw.smw.ask(s
..'|mainlabel=-'
..'|?Kurzname#='
..'|?Lehenstyp#='
..'|?Wappen ist#='
..'|?Vasallenlehen von#='
..'|limit=1'
..'|searchlabel='
)
if details==nil then return {} end
return details
end
 
function holeLehenSub(mitglied)
if mitglied=='' then return {} end
local s='[[-has subobject::'..mitglied..']]'
local lehen=mw.smw.ask(s
..'|mainlabel=-'
..'|?Herrscher von Lehen#='
..'|?Herrscher von Art#='
..'|?Herrscher von VonIndex#='
..'|?Herrscher von BisIndex#='
..'|limit=500'
..'|searchlabel='
..'|sort=Herrscher von VonIndex'
)
if lehen==nil then return {} end
return lehen
end
end


function holelehensub(frame,person)
function findeFamilienmitglieder(familie)
if person=='' then return '' end
local s='<q>[[Familienmitglied von::'..familie..']] OR [[Familienmitglied von.Untergruppierung von::'..familie..']]</q>'
local s='[[-has subobject::'..person..']] [[Herrscher von BisIndex::99990000]]'
local mitglieder=mw.smw.ask(s
local a=frame:callParserFunction(
..'|mainlabel=-'
  '#ask',s,
..'|?#-='
  'mainlabel=-',
..'|limit=500'
  '?Herrscher von Lehen#=',
..'|searchlabel='
  'limit=500',
)
  'searchlabel=',
if mitglieder==nil then mitglieder={} end
  'format=list'
return mitglieder
)
return a
end
end


function findeAlleLehen(mitglieder,jahr)
local allelehen={}
for mkey,mvalue in pairs(mitglieder) do
local lehen=holeLehenSub(mvalue[1])
for lkey,lvalue in pairs(lehen) do
if lvalue[1]~=nil and lvalue[2]~=nil and lvalue[3]~=nil and lvalue[4]~=nil then
if allelehen[lvalue[1]]==nil then allelehen[lvalue[1]]={} end
local von=lvalue[3]/10000
local bis=lvalue[4]/10000
if allelehen[lvalue[1]]['aktuell']==nil then allelehen[lvalue[1]]['aktuell']=false end
if bis>jahr then
bis=jahr
allelehen[lvalue[1]]['aktuell']=true
end
local v=3
if lvalue[2]=='Titel' then v=2 end
if lvalue[2]=='Regent' then v=1 end
for i=von,bis,1 do
allelehen[lvalue[1]][i]=v
end
end
end
end
return allelehen
end


function holelehen(frame,familie)
function verdichteLehen(allelehen,manuell)
if familie=='' then return '' end
local lehensarten={}
lehensarten['Reich']='Reiche'
--Finde alle lebenden Familienmitglieder
lehensarten['Provinz']='Provinzen'
local s='<q>[[Familienmitglied von::'..familie..']] OR [[Familienmitglied von.Untergruppierung von::'..familie..']]</q> [[Lebend::Ja]]'
lehensarten['Grafschaft']='Grafschaften'
local a=frame:callParserFunction(
lehensarten['Baronie']='Baronien'
  '#ask',s,
lehensarten['Junkertum']='Junkertümer'
  'mainlabel=-',
lehensarten['Herrschaft']='Herrschaften'
  '?#=',
lehensarten['Ortschaft']='Ortschaften'
  'limit=500',
lehensarten['Bauwerk']='Bauwerke'
  'searchlabel=',
  'format=list'
)


--Finde alle aktiven Lehen dieser Familienmitglieder
local lehenverdichtet={}
local result={}
for akey,avalue in pairs(allelehen) do
local t=mw.text.split(a,',',true)
local countr=0;
for key,value in pairs(t) do
local countt=0;
  if robusttrim(value)~='' then
for jkey,jvalue in pairs(avalue) do
  local l=holelehensub(frame,value)
if (jvalue==1)or(jvalue==3) then countr=countr+1 end
if (jvalue==2)or(jvalue==3) then countt=countt+1 end
end
local details=holeLehenDetails(akey)
if (details[1]~=nil) and (details[1][2]~=nil) and (lehensarten[details[1][2]]~=nil) then
local art=lehensarten[details[1][2]]
if lehenverdichtet[art]==nil then lehenverdichtet[art]={} end
lehenverdichtet[art][akey]={}
lehenverdichtet[art][akey]['kurzname']=details[1][1]
lehenverdichtet[art][akey]['aktuell']=avalue['aktuell']
lehenverdichtet[art][akey]['regent']=countr
lehenverdichtet[art][akey]['titel']=countt
lehenverdichtet[art][akey]['wappen']=details[1][3]
lehenverdichtet[art][akey]['hegemon']=details[1][4]
end
end
--manuell einmischen, nur wenn nicht bereits dabei
local manuellt=mw.text.split(manuell,',',true)
for mkey,akey in pairs(manuellt) do
local details=holeLehenDetails(akey)
if (details[1]~=nil) and (details[1][2]~=nil) and (lehensarten[details[1][2]]~=nil) then
local art=lehensarten[details[1][2]]
if lehenverdichtet[art]==nil then lehenverdichtet[art]={} end
if lehenverdichtet[art][akey]==nil then
lehenverdichtet[art][akey]={}
lehenverdichtet[art][akey]['kurzname']=details[1][1]
lehenverdichtet[art][akey]['aktuell']=true -- geht natürlich nicht
lehenverdichtet[art][akey]['regent']=1 --geht natürlich nicht
lehenverdichtet[art][akey]['titel']=1 --geht natürlich nicht
lehenverdichtet[art][akey]['wappen']=details[1][3]
lehenverdichtet[art][akey]['hegemon']=details[1][4]
end
end
end
return lehenverdichtet
end


  --Finde die Art des Lehens dieses Familienmitglieds
function holeLehen(jahr,familie,manuell)
  local t2=mw.text.split(l,',',true)
if familie=='' then return '' end
  for key2,value2 in pairs(t2) do
    if robusttrim(value2)~='' then
    local d=holelehenattribut(frame,value2,'Lehenstyp')
    local k=holelehenattribut(frame,value2,'Kurzname')
    local i=holelehenattribut(frame,value2,'Icon ist')
    if(result[d]==nil) then result[d]={} end
    table.insert(result[d],{["Artikel"]=value2,["Kurzname"]=k,["Icon"]=i});
    end
  end


  end
--Finde alle Familienmitglieder
end
local mitglieder=findeFamilienmitglieder(familie)
return result
end
--Finde alle Lehen dieser Familienmitglieder
local allelehen=findeAlleLehen(mitglieder,jahr)


function holelehenattribut(frame,lehen,attribut)
--Verdichte das Ergebnis auf Lehensart und Lehen
if lehen=='' then return 'unbekannt' end
local lehenverdichtet=verdichteLehen(allelehen,manuell)
local a=frame:callParserFunction(
  '#show',lehen,
  '?'..attribut..'#'
)
if a=='' then a='unbekannt' end
return a
end;


function kategorisiereUndHegemon(frame,lehen,title,catname,rekursion)
return lehenverdichtet
if lehen=='' then return '' end
end
if rekursion==0 then return '' end
local heg=frame:callParserFunction(
  '#show',lehen,
  '?Vasallenlehen von#'
)
hegsub=''
if heg~=''then
  t=mw.title.new(heg).text
  hegsub=kategorisiereUndHegemon(frame,heg,t,catname,rekursion-1)
end


return '[[Kategorie:'..title..'|'..catname..']]'..hegsub
function sortiereLehen(t,a,b)
return t[a]['kurzname']<t[b]['kurzname']
end
end


function printlehensub(frame,lehentable,catname,art,artpl)  
function sortiereLehensarten(t,a,b)
result=''
local lehenssort={}
if(lehentable[art]~=nil) then
lehenssort['Reiche']=0
  result=''
lehenssort['Provinzen']=1
  for key,value in pairs(lehentable[art]) do
lehenssort['Grafschaften']=2
  t=mw.title.new(value["Artikel"]).text
lehenssort['Baronien']=3
  result=result..'[['..value["Artikel"]..'|'..value["Kurzname"]..']]'..kategorisiereUndHegemon(frame,value["Artikel"],t,catname,7)..', '
lehenssort['Junkertümer']=4
  end
lehenssort['Herrschaften']=5
end
lehenssort['Ortschaften']=6
result=mw.ustring.sub(result,1,mw.ustring.len(result)-2)
lehenssort['Bauwerke']=7
return frame:callParserFunction('#invoke','Text','Zeile',artpl,result)
return lehenssort[a]<lehenssort[b]
end
end


function printlehen(frame,lehentable,catname,weiterelehen,weitereaemter)
function formatiereLehen(lehenverdichtet,weiterelehen,weitereaemter,aktuell)
result=''
local result=''
result=result..printlehensub(frame,lehentable,catname,'Reich','Reiche')
for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
result=result..printlehensub(frame,lehentable,catname,'Provinz','Provinzen')
local werte={}
result=result..printlehensub(frame,lehentable,catname,'Grafschaft','Grafschaften')
for lkey,lvalue in spairs(vvalue,sortiereLehen) do
result=result..printlehensub(frame,lehentable,catname,'Baronie','Baronien')
if aktuell==lvalue['aktuell'] then
result=result..printlehensub(frame,lehentable,catname,'Junkertum','Junkertümer')
local regent=''
result=result..printlehensub(frame,lehentable,catname,'Herrschaft','Herrschaften')
if lvalue['titel']==0 and lvalue['regent']>0 then regent=' (Regentschaft)' end
result=result..frame:callParserFunction('#invoke','Text','Zeile','Weitere Lehen',weiterelehen)
table.insert(werte,'[['..lkey..'|'..lvalue['kurzname']..']]'..regent)
result=result..frame:callParserFunction('#invoke','Text','Zeile','Weitere Ämter',weitereaemter)
end
return frame:callParserFunction('#invoke','Text','Zeilengruppe','Lehen',result)
end
result=result..subZeile(vkey,table.concat(werte,', '))
end
result=result..subZeile('Weitere Lehen',weiterelehen)
result=result..subZeile('Weitere Ämter',weitereaemter)
local pre='Aktuelle '
if not aktuell then pre='Ehemalige ' end
return subZeilengruppe(pre..'Lehen und Ämter',result)
end
end


function printleheniconsub(frame,lehentable,art)  
function kategorieHegemonRekursiv(lehen,kurzname,rekursion)
result=''
if rekursion==0 then return '' end
if(lehentable[art]~=nil) then
if type(lehen)=='table' then
  result=''
local result=''
  for key,value in pairs(lehentable[art]) do
for key,value in pairs(lehen) do
  result=result..'[['..value['Icon']..'|20px|link='..value['Artikel']..']]&nbsp;&nbsp;&nbsp;'
result=result..kategorieHegemonRekursiv(value,kurzname,rekursion)
  end
end
end
return result
return result
end
if lehen==nil or lehen=='' or type(lehen)~='string' then return '' end
local title=mw.title.new(lehen).text
local s='[['..lehen..']]'
local hegemon=mw.smw.ask(s
..'|mainlabel=-'
..'|?Vasallenlehen von#='
..'|limit=1'
..'|searchlabel='
)
local add=''
if hegemon[1][1]~=nil then
add=kategorieHegemonRekursiv(hegemon[1][1],kurzname,rekursion-1)
end
return '[[Kategorie:'..title..'|'..kurzname..']]'..add
end
end


function printlehenicon(frame,lehentable)
function kategorisiereLehen(lehenverdichtet)
result=''
local result=''
result=result..printleheniconsub(frame,lehentable,'Reich')
for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
result=result..printleheniconsub(frame,lehentable,'Provinz')
local werte={}
result=result..printleheniconsub(frame,lehentable,'Grafschaft')
for lkey,lvalue in spairs(vvalue,sortiereLehen) do
result=result..printleheniconsub(frame,lehentable,'Baronie')
local title=mw.title.new(lkey).text
result=result..printleheniconsub(frame,lehentable,'Junkertum')
result=result..' [[Kategorie:'..title..'|'..lvalue['kurzname']..']]'..kategorieHegemonRekursiv(lvalue['hegemon'],lvalue['kurzname'],7)
result=result..printleheniconsub(frame,lehentable,'Herrschaft')
end
return result
end
return result
end
end


function formatiereLehenIcons(lehenverdichtet)
local result=''
for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
local werte={}
for lkey,lvalue in spairs(vvalue,sortiereLehen) do
if lvalue['aktuell'] then
result=result..'[['..lvalue['wappen']..'|20px|link='..lkey..']]&nbsp;&nbsp;&nbsp;'
end
end
end
return result
end


function p.Abfrage(frame)
function p.Abfrage(frame)
if (frame.args[1]==nil) then
if (frame.args[1]==nil) then
  return "no parameter found"
return 'no parameter found'
end
end
catname=robusttrim(frame.args[2])
catname=robusttrim(frame.args[2])
weiterelehen=robusttrim(frame.args[3])
weiterelehen=robusttrim(frame.args[3])
weitereaemter=robusttrim(frame.args[4])
weitereaemter=robusttrim(frame.args[4])
local familie=frame.args[1]
manuell=robusttrim(frame.args[5])
local result=holelehen(frame,familie)
local familie=frame.args[1]
frame:callParserFunction('#vardefine','LehensabfrageIcons',printlehenicon(frame,result))
local lehen=holeLehen(1047,familie,manuell)
return printlehen(frame,result,catname,weiterelehen,weitereaemter)
local formatiert=formatiereLehen(lehen,weiterelehen,weitereaemter,true)
frame:callParserFunction('#vardefine','LehensabfrageIcons',formatiereLehenIcons(lehen))
frame:callParserFunction('#vardefine','Lehensabfrage',formatiert)
return formatiert..formatiereLehen(lehen,'','',false)..kategorisiereLehen(lehen)
end
end


return p
return p

Aktuelle Version vom 1. Juli 2024, 11:06 Uhr

Dokumentation und Testfälle unter Modul:Lehensabfrage/Doku.
local p = {}

require("Modul:Hilfsfunktionen")
require("Modul:Text")

function holeLehenDetails(lehen)
	if lehen=='' then return {} end
	local s='[['..lehen..']]'
	local details=mw.smw.ask(s
		..'|mainlabel=-'
		..'|?Kurzname#='
		..'|?Lehenstyp#='
		..'|?Wappen ist#='
		..'|?Vasallenlehen von#='
		..'|limit=1'
		..'|searchlabel='
	)
	if details==nil then return {} end
	return details
end

function holeLehenSub(mitglied)
	if mitglied=='' then return {} end
	local s='[[-has subobject::'..mitglied..']]'
	local lehen=mw.smw.ask(s
		..'|mainlabel=-'
		..'|?Herrscher von Lehen#='
		..'|?Herrscher von Art#='
		..'|?Herrscher von VonIndex#='
		..'|?Herrscher von BisIndex#='
		..'|limit=500'
		..'|searchlabel='
		..'|sort=Herrscher von VonIndex'
	)
	if lehen==nil then return {} end
	return lehen
end

function findeFamilienmitglieder(familie)
	local s='<q>[[Familienmitglied von::'..familie..']] OR [[Familienmitglied von.Untergruppierung von::'..familie..']]</q>'
	local mitglieder=mw.smw.ask(s
		..'|mainlabel=-'
		..'|?#-='
		..'|limit=500'
		..'|searchlabel='
	)
	if mitglieder==nil then mitglieder={} end
	return mitglieder
end

function findeAlleLehen(mitglieder,jahr)
	local allelehen={}
	for mkey,mvalue in pairs(mitglieder) do
		local lehen=holeLehenSub(mvalue[1])
		for lkey,lvalue in pairs(lehen) do
			if lvalue[1]~=nil and lvalue[2]~=nil and lvalue[3]~=nil and lvalue[4]~=nil then
				if allelehen[lvalue[1]]==nil then allelehen[lvalue[1]]={} end
				local von=lvalue[3]/10000
				local bis=lvalue[4]/10000
				if allelehen[lvalue[1]]['aktuell']==nil then allelehen[lvalue[1]]['aktuell']=false end
				if bis>jahr then
					bis=jahr
					allelehen[lvalue[1]]['aktuell']=true
				end
				local v=3
				if lvalue[2]=='Titel' then v=2 end
				if lvalue[2]=='Regent' then v=1 end
				for i=von,bis,1 do
					allelehen[lvalue[1]][i]=v
				end
			end
		end
	end
	return allelehen
end

function verdichteLehen(allelehen,manuell)
	local lehensarten={}
	lehensarten['Reich']='Reiche'
	lehensarten['Provinz']='Provinzen'
	lehensarten['Grafschaft']='Grafschaften'
	lehensarten['Baronie']='Baronien'
	lehensarten['Junkertum']='Junkertümer'
	lehensarten['Herrschaft']='Herrschaften'
	lehensarten['Ortschaft']='Ortschaften'
	lehensarten['Bauwerk']='Bauwerke'

	local lehenverdichtet={}
	for akey,avalue in pairs(allelehen) do
		local countr=0;
		local countt=0;
		for jkey,jvalue in pairs(avalue) do
			if (jvalue==1)or(jvalue==3) then countr=countr+1 end
			if (jvalue==2)or(jvalue==3) then countt=countt+1 end
		end
		local details=holeLehenDetails(akey)
		if (details[1]~=nil) and (details[1][2]~=nil) and (lehensarten[details[1][2]]~=nil) then
			local art=lehensarten[details[1][2]]
			if lehenverdichtet[art]==nil then lehenverdichtet[art]={} end
			lehenverdichtet[art][akey]={}
			lehenverdichtet[art][akey]['kurzname']=details[1][1]
			lehenverdichtet[art][akey]['aktuell']=avalue['aktuell']
			lehenverdichtet[art][akey]['regent']=countr
			lehenverdichtet[art][akey]['titel']=countt
			lehenverdichtet[art][akey]['wappen']=details[1][3]
			lehenverdichtet[art][akey]['hegemon']=details[1][4]
		end
	end
	--manuell einmischen, nur wenn nicht bereits dabei
	local manuellt=mw.text.split(manuell,',',true)
	for mkey,akey in pairs(manuellt) do
		local details=holeLehenDetails(akey)
		if (details[1]~=nil) and (details[1][2]~=nil) and (lehensarten[details[1][2]]~=nil) then
			local art=lehensarten[details[1][2]]
			if lehenverdichtet[art]==nil then lehenverdichtet[art]={} end
			if lehenverdichtet[art][akey]==nil then
				lehenverdichtet[art][akey]={}
				lehenverdichtet[art][akey]['kurzname']=details[1][1]
				lehenverdichtet[art][akey]['aktuell']=true -- geht natürlich nicht
				lehenverdichtet[art][akey]['regent']=1 --geht natürlich nicht
				lehenverdichtet[art][akey]['titel']=1 --geht natürlich nicht
				lehenverdichtet[art][akey]['wappen']=details[1][3]
				lehenverdichtet[art][akey]['hegemon']=details[1][4]
			end
		end
	end
	return lehenverdichtet
end

function holeLehen(jahr,familie,manuell)
	if familie=='' then return '' end

	--Finde alle Familienmitglieder
	local mitglieder=findeFamilienmitglieder(familie)
	
	--Finde alle Lehen dieser Familienmitglieder
	local allelehen=findeAlleLehen(mitglieder,jahr)

	--Verdichte das Ergebnis auf Lehensart und Lehen
	local lehenverdichtet=verdichteLehen(allelehen,manuell)

	return lehenverdichtet	
end

function sortiereLehen(t,a,b)
	return t[a]['kurzname']<t[b]['kurzname']
end

function sortiereLehensarten(t,a,b)
	local lehenssort={}
	lehenssort['Reiche']=0
	lehenssort['Provinzen']=1
	lehenssort['Grafschaften']=2
	lehenssort['Baronien']=3
	lehenssort['Junkertümer']=4
	lehenssort['Herrschaften']=5
	lehenssort['Ortschaften']=6
	lehenssort['Bauwerke']=7
	return lehenssort[a]<lehenssort[b]
end

function formatiereLehen(lehenverdichtet,weiterelehen,weitereaemter,aktuell)
	local result=''
	for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
		local werte={}
		for lkey,lvalue in spairs(vvalue,sortiereLehen) do
			if aktuell==lvalue['aktuell'] then
				local regent=''
				if lvalue['titel']==0 and lvalue['regent']>0 then regent=' (Regentschaft)' end
				table.insert(werte,'[['..lkey..'|'..lvalue['kurzname']..']]'..regent)
			end	
		end
		result=result..subZeile(vkey,table.concat(werte,', '))
	end
	result=result..subZeile('Weitere Lehen',weiterelehen)
	result=result..subZeile('Weitere Ämter',weitereaemter)
	local pre='Aktuelle '
	if not aktuell then pre='Ehemalige ' end
 	return subZeilengruppe(pre..'Lehen und Ämter',result)
end

function kategorieHegemonRekursiv(lehen,kurzname,rekursion)
	if rekursion==0 then return '' end
	if type(lehen)=='table' then
		local result=''
		for key,value in pairs(lehen) do
			result=result..kategorieHegemonRekursiv(value,kurzname,rekursion)
		end
		return result
	end
	if lehen==nil or lehen=='' or type(lehen)~='string' then return '' end
	local title=mw.title.new(lehen).text
	local s='[['..lehen..']]'
	local hegemon=mw.smw.ask(s
		..'|mainlabel=-'
		..'|?Vasallenlehen von#='
		..'|limit=1'
		..'|searchlabel='
	)
	local add=''
	if hegemon[1][1]~=nil then
		add=kategorieHegemonRekursiv(hegemon[1][1],kurzname,rekursion-1)
	end
	return '[[Kategorie:'..title..'|'..kurzname..']]'..add
end

function kategorisiereLehen(lehenverdichtet)
	local result=''
	for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
		local werte={}
		for lkey,lvalue in spairs(vvalue,sortiereLehen) do
			local title=mw.title.new(lkey).text
			result=result..' [[Kategorie:'..title..'|'..lvalue['kurzname']..']]'..kategorieHegemonRekursiv(lvalue['hegemon'],lvalue['kurzname'],7)
		end
	end
 	return result
end

function formatiereLehenIcons(lehenverdichtet)
	local result=''
	for vkey,vvalue in spairs(lehenverdichtet,sortiereLehensarten) do
		local werte={}
		for lkey,lvalue in spairs(vvalue,sortiereLehen) do
			if lvalue['aktuell'] then
				result=result..'[['..lvalue['wappen']..'|20px|link='..lkey..']]&nbsp;&nbsp;&nbsp;'
			end
		end
	end
 	return result
end

function p.Abfrage(frame)
	if (frame.args[1]==nil) then
		return 'no parameter found'
	end
	catname=robusttrim(frame.args[2])
	weiterelehen=robusttrim(frame.args[3])
	weitereaemter=robusttrim(frame.args[4])
	manuell=robusttrim(frame.args[5])
	local familie=frame.args[1]
	local lehen=holeLehen(1047,familie,manuell)
	local formatiert=formatiereLehen(lehen,weiterelehen,weitereaemter,true)
	frame:callParserFunction('#vardefine','LehensabfrageIcons',formatiereLehenIcons(lehen))
	frame:callParserFunction('#vardefine','Lehensabfrage',formatiert)
	return formatiert..formatiereLehen(lehen,'','',false)..kategorisiereLehen(lehen)
end

return p