Modul:Vorlage:Infobox Sendeanlage

Vorlagenprogrammierung	Diskussionen	Lua		Test	Unterseiten
		Modul	Deutsch		Modul:	Dokumentation

Diese Seite enthält Code in der Programmiersprache Lua. Einbindungszahl Cirrus

---

-- Allgemeine Variablen
local ModulStamm = "Modul:Vorlage:Infobox Sendeanlage" -- Stammverzeichnis des Moduls
local SN = mw.title.getCurrentTitle().text -- Seitenname des Artikels
local SR = mw.title.getCurrentTitle().rootText -- Basis-Seitenname des Artikels
local SU = mw.title.getCurrentTitle().subpageText -- Name der Unterseite des Artikels
-- local SI = mw.title.getCurrentTitle():getContent() -- Inhalt der Artikelseite
local NSP = mw.title.getCurrentTitle().namespace -- Namensraum des Artikels
local ZN = 0 -- allgemeiner Zaehler
local ZZ = "" -- allgemeines Zeichen
local ZF = {} -- allgemeines Feld
local Daten = { }
local Kategorien = { { } }
local DN = {}

-- Zuladen exportierter Datensaetze
local Label = require( ModulStamm .. "/Label" )
local Daten = Label.Label( SN )
local Geo = Label.Geo()
local Bezeichner = Label.Bezeichner()
local Tabelle = Label.Tabelle()
local OPK = Label.OPK()

-- Ermittung Typ des Bauwerkes
function TYP( Alle, DatenWL, frame )
	local WLD = mw.getCurrentFrame():getParent().args.CAT_TYP
	if (WLD == "" or WLD == nil) then WLD = frame.args.CAT_TYP end
	if (WLD == "" or WLD == nil) then WLD = DatenWL end
	if (WLD == "" or WLD == nil) then WLD = "Anlage" end
	return WLD
end

function CCN( SN, DatenWL, frame )
	local NCC = { }
	local ZZ = ""
	local YY = ""
	
	-- Ermittlung Stadt-Kategorie
	ZZ = mw.getCurrentFrame():getParent().args.CAT_STADT
	if (ZZ == "" or ZZ == nil) then ZZ = frame.args.CAT_STADT end
	if (ZZ == "" or ZZ == nil) then ZZ = DatenWL.CAT_STADT end
	if ZZ == nil then ZZ = "" end
	YY = mw.text.split( ZZ, "/")
	NCC.CSTADT = { }
	NCC.DSTADT = { }
	for DCk, DCv in pairs( YY ) do
		if string.sub( DCv, 0, 7 ) == "in der " then
			NCC.CSTADT[DCk] = string.sub( DCv, 8 )
			NCC.DSTADT[DCk] = DCv
		elseif (string.sub( DCv, 0, 3 ) == "in " or string.sub( DCv, 0, 3 ) == "im ") then
			NCC.CSTADT[DCk] = string.sub( DCv, 4 )
			NCC.DSTADT[DCk] = DCv
		else
			NCC.CSTADT[DCk] = DCv
			NCC.DSTADT[DCk] = "in " .. DCv
		end
	end
	if NCC.CSTADT[1] == "" then
		NCC.CSTADT[1] = nil
		NCC.DSTADT[1] = nil
	end
	
	-- weitere Ermittlungen zur Kategorisierung
	ZZ = mw.getCurrentFrame():getParent().args["NAME"]
	if (ZZ == "" or ZZ == nil) then ZZ = frame.args["NAME"] end
	if (ZZ == "" or ZZ == nil) then ZZ = DatenWL["NAME"] end
	if ZZ == "" then ZZ = nil end
	NCC.NNAME = ZZ or SN
	ZZ = mw.getCurrentFrame():getParent().args.CAT_NAME
	if (ZZ == "" or ZZ == nil) then ZZ = frame.args.CAT_NAME end
	if (ZZ == "" or ZZ == nil) then ZZ = DatenWL.CAT_NAME end
	if ZZ == "" then ZZ = nil end
	NCC.CNAME = ZZ or NCC.NNAME
	return NCC
end

-- Datensaetze aufbereiten
function DS_Aufbereitung( DSZusatz, DatenX, frame )
	-- Datenvariablen extrahieren
	local Daten = DatenX
	local DN = { }
	local Kategorien = { }
	
	-- Einzeldurchgang der Datensaetze
	for DSi, DS in pairs( Daten ) do
		
		-- Standard-Aufarbeitung aus Auslagerung aufrufen
		ZF = DSZusatz.Aufbereitung.AufarbStand( DS, DSZusatz, Kategorien, frame )
		DS = ZF.DS
		Kategorien = ZF.Kategorien
		
		-- DN erzeugen
		DN[DS.Name] = DS
	end
	if DSZusatz.Typ == "Mast" then table.insert( Kategorien, { "Sendemast", "Cat", Name = "TypMast" } ) end
	
	
	-- Datensaetze fuer Infobox bearbeiten
	local DSMA = {
		"NAME", --        Einheitlicher Parameter NAME
		"UE1", --         Ueberschrift der Infobox
		"IBBild", --      Anzeige Bild
		"Regionen", --    Anzeige der Regionen (Bundesland, Staat)
		"LAGEPUNKT", --   Hoehenlage
		"ZUGANG", --      Zugaenglichkeit
		"IBTBau", --      Zusammenfassung fuer Turmbau
		"IBTHoch", --     Zusammenfassung fuer Turm-Einzelhoehen
		"IBSHoch", --     Zusammenfassung fuer Sendeanlagen-Einzelheiten
		"KOORDINATEN", -- Gueltigkeitspruefung 'KOORDINATEN'
		"POSKARTE", --    Positionskarte 'POSKARTE'
		"KoordKarte" --   Anzeige Koordinaten 'KoordKarte'
	}
	local DSIB = {} --  nur uebergangsweise
	
		-- Anzeige Test
	DSIB.Test = function ( DN, DSZusatz, Kategorien, frame )
		
		local DSMB = { }
		
		return DN
	end
	
	for DSMAk, DSMAv in pairs( DSMA ) do
		DN = DSZusatz.Aufbereitung.DSIB[DSMAv]( DN, DSZusatz, Kategorien, frame )
		if DN.TMP_KAT then
			for DSMAx, DSMAy in pairs( DN.TMP_KAT ) do
				table.insert( Kategorien, DSMAy )
			end
			DN.TMP_KAT = nil
		end
	end
	
	DN = DSIB.Test( DN, DSZusatz, Kategorien, frame )
	
	
	-- Bau- und Abrissdekade
	if DN.BAU_DEKADE.WertZeile then table.insert( Kategorien, { "Erbaut in den " .. DN.BAU_DEKADE.WertZeile .. "0er Jahren" } ) end
	if DN.ABR_DEKADE.WertZeile then
		table.insert( Kategorien, { "Zerstört in den " .. DN.ABR_DEKADE.WertZeile .. "0er Jahren" } )
		table.insert( Kategorien, { "Abgegangenes Bauwerk", "GeoN"  } )
	end
	
	-- Ehemaliger Gastronomiebetrieb
	local EGB = { Restaurant = false, Abriss = false, Dekade = false }
	for EGB1k, KFS1v in pairs( DN.VERW.WertSplit ) do
		if (KFS1v == "Restaurant" or KFS1v == "Drehrestaurant") then EGB.Restaurant = true end
	end
	if DN.ABRISS.WertZeile then EGB.Abriss = true end
	if DN.ABR_DEKADE.WertZeile then EGB.Dekade = true end
	if (EGB.Restaurant == true and (EGB.Abriss == true or EGB.Dekade == true) )	then table.insert( Kategorien, { "Ehemaliger Gastronomiebetrieb", "GeoN"  } ) end
	
	-- Datenvariablen fuer Rueckgabe vorbereiten
	local DSRueck = {
		Daten = Daten,
		DN = DN,
		Kategorien = Kategorien
	}	
	return DSRueck
end

-- Wartung
function Wartung( DSZusatz, Daten, DN, Kategorien, frame )
	local WartungGesamt = require( ModulStamm .. "/Wartung" )
	local Wartung = {
		WartungGesamt.WartungLua( DSZusatz, Daten, DN, Kategorien, frame ),
		WartungGesamt.WartungWiki( DSZusatz, DN, frame ),
		Text = ""
	}
	Wartung.alle =  Wartung[1] .. Wartung[2]
	if DSZusatz.NSP == 0 then Wartung.Text = Wartung.alle end
	return Wartung.Text
end

-- Kategorien aufbereiten
function KatFinder( DSZusatz, Daten, DN, Kategorien, frame )
	local RegKAT = { } --  Regions-Kategorien
	--                 --  [1] = nach Region, [2] Regions-Kategorie-Name
	local GeoKAT = { } --  Geo-Kategorien: ["Name"] = Name der Kategorie [1] = Name mit Geo, [2] = Sortierung, [3] = Stand in der Abfolge
	local GeoKAT1 = 0 --   Geo-Kategorien-Zaehler
	local LaufTyp = { } -- Geo-Kategorien aus den Aufzaehlungern (z.B. Verwendung): [1] = Name der Kategorie, [2] = Sortierung
	local LaufGeo = { } -- Durchlauf der zu pruefenden Kategorien
	local LaufGeo1 = 1  -- Durchlauf-Zaehler der zu pruefenden Kategorien
	local DopplerT = "" -- Speicher der doppelten Kategorien nach Typ, z. B. SendeturmDeutschland
	local DopplerR = "" -- Speicher der doppelten Kategorien nach Region, z. B. Deutschland
	local KATmax = 0 --    maximale Tiefe der 'GeoKAT'
	local KATText = "" --  Tabelle zur erstellung Liste zur Fehlersuche
	local ZY = nil
	local ZZ = ""
	KATText = "\n=== Auswertung Kategorien zur Fehlersuche ==="
	
	-- Regions-Kategorien finden
	function RKAT( Art, REGION, CSTADT, DSAB )
		local RegKAT, Typ, RegTEMP = { }, 1, { Sub = "1" }
		RegTEMP.GL = {
			{ "Irland", "Bauwerk" },
			{ "Tschechien", "Bauwerk" }
		}
		if type( Art ) == "table" then Typ = Art[1] end
		if not REGION then REGION = { } end
		if REGION["2"] then
			for GLk, GLv in pairs( RegTEMP.GL ) do
				if (REGION["0"]["name"] == GLv[1] and Typ == GLv[2]) then RegTEMP.Sub = "2" end
			end
		end
		if REGION["0"] then RegKAT[1] = { DSZusatz.Aufbereitung.GeoVERW( Typ, "REG", "0", REGION ), REGION["0"]["name"], Art = "REGION" } end
		if REGION["1"] then RegKAT[2] = { DSZusatz.Aufbereitung.GeoVERW( Typ, "REG", RegTEMP.Sub, REGION ), REGION[RegTEMP.Sub]["name"], Art = "REGION" } end
		if REGION["2"] then RegKAT[3] = { DSZusatz.Aufbereitung.GeoVERW( Typ, "REG", "2", REGION ), REGION["2"]["name"], Art = "REGION" } end
		if not CSTADT then CSTADT = { } end
		for KFSk, KFSv in pairs( CSTADT ) do
			if (KFSv ~= nil and KFSv ~= "") then
				table.insert( RegKAT, { DSZusatz.Aufbereitung.GeoVERW( Typ, "CSTADT", KFSv, REGION, DSZusatz.DSTADT[KFSk] ), KFSv, Art = "CSTADT" } )
			end
		end
		table.insert( RegKAT, { "nichts", "nicht", Art = "nicht" } )

		return RegKAT
	end
	RegKAT = RKAT( { "Start" }, DSZusatz.REGION, DSZusatz.CSTADT, DSZusatz.Aufbereitung )
	
	-- Durchlaufwerte (LG0) bestimmen
		-- Laufwerte nach Bauwerkstyp
	KATText = KATText .. "\n=== Laufwerte nach Bauwerkstyp ==="
	local GeoSort, GeoDoppler = { }, { }
	if DSZusatz.Geo[DSZusatz.Typ] then
		GeoSort[1] = DSZusatz.Typ
		GeoDoppler[DSZusatz.Typ] = true
	end
	for GS1k, GS1v in pairs( Kategorien ) do
		if GS1v[3] then
			if (not GeoDoppler[GS1v[3]] and DSZusatz.Geo[GS1v[3]]) then
				table.insert( GeoSort, GS1v[3] )
				GeoDoppler[GS1v[3]] = true
			end
		end
	end
	if #GeoSort == 0 then
		GeoSort[1] = 1
		GeoDoppler = true
	end
	for GS9k, GS9v in pairs( GeoSort ) do
		KATText = KATText .. "\n# " .. tostring( GS9v )
	end
	
	for GS2k, GS2v in pairs( GeoSort ) do
		if type( DSZusatz.Geo[GS2v] ) == "table" then
			if type( DSZusatz.Geo[GS2v][1] ) == "table" then
				if type( DSZusatz.Geo[GS2v][1][1] ) == "table" then
					if type( DSZusatz.Geo[GS2v][1][1][1] ) == "string" then
						table.insert( LaufGeo, DSZusatz.Geo[GS2v] )
					end
				end
			end
		end
	end
	
		-- Geo-Kategorien finden
	for KFGk, KFGv in pairs( Kategorien ) do
		if ((KFGv[2] == "GeoN" or KFGv[2] == "GeoC") and not KFGv[3]) then
			table.insert( LaufGeo, { { { KFGv[1], KFGv[2] } } } )
		end
	end
	
	-- Durchlauf nach Geo-Kaskade nach Bauwerkstyp
	local RegWEGd = { }
	for LG0k, LG0v in pairs( LaufGeo ) do
		KATText = KATText .. "\n# „LG0v“ : " .. tostring( LG0v )
		for LG1k, LG1v in pairs( LG0v ) do
			KATText = KATText .. "\n## „LG1v“ : " .. tostring( LG1v )
			LaufGeo1 = 1
			for LG2k, LG2v in pairs( LG0v[LG1k] ) do
				KATText = KATText .. "\n### „LG2v[1]“ : " .. tostring( LG2v[1] )
				ZY = ""
				RegKAT = RKAT( LG2v, DSZusatz.REGION, DSZusatz.CSTADT, DSZusatz.Aufbereitung )
				for LG3k=LaufGeo1, table.maxn( RegKAT ), 1 do
					DopplerT = RegKAT[LG3k]["Art"] .. LG2v[1] .. RegKAT[LG3k][2]
					DopplerR = RegKAT[LG3k]["Art"] .. RegKAT[LG3k][2]
					if (ZY == nil and RegKAT[LG3k][2] == "nix") then DopplerT = "nix" end
					if (GeoKAT[DopplerT] == nil and GeoKAT[DopplerR] == nil) then
						ZZ = "0"
						if ZY then
							ZZ = mw.getCurrentFrame():callParserFunction( "#ifexist", { "Kategorie:" .. LG2v[1] .. " " .. RegKAT[LG3k][1], LG2v[1] .. " " .. RegKAT[LG3k][1], "0" } )
						end
						if (ZZ == "0" and ZY ~= nil) then
							if ((DopplerT ~= "nix" or DopplerR ~= "nix") and ZY ~= "") then
								GeoKAT1 = GeoKAT1 + 1
								GeoKAT[GeoKAT1] = { ZY, LG2v[2], LG3k - 1, Name = LG2v[1] }
								if KATmax < LG3k then KATmax = LG3k end
								KATText = KATText .. "\n#### GeoKAT[" .. tostring( GeoKAT1 ) .. "] = { [1]=„" .. tostring( GeoKAT[GeoKAT1][1] ) .. "“, [2]=„" .. tostring( GeoKAT[GeoKAT1][2] ) .. "“, [3]=„" .. tostring( GeoKAT[GeoKAT1][3] ) .. "“, Name=„" .. tostring( GeoKAT[GeoKAT1]["Name"] ) .. "“ }"
							end
							ZY = nil
						else
							if ZY then
								ZY = ZZ
								LaufGeo1 = LG3k + 1
								GeoKAT[DopplerT] = true
								GeoKAT[DopplerR] = true
							end
						end
					end
				end
			end
		end
		RegWEGd = {
			Daten = GeoKAT -- Datenablage
		}
		GeoKAT = { }
		for GeoKATk, GeoKATv in pairs( RegWEGd.Daten ) do
			if type( GeoKATk ) == "number" then GeoKAT[GeoKATk] = GeoKATv end
		end
	end
	RegWEGd = {
		Daten = GeoKAT, --    Datenablage
		Doppler = {}, --      Ablage der Doppler
		istschonda = false -- ist Eintrag schon vorhanden?
	}
	GeoKAT = { }
	for GeoKATk, GeoKATv in pairs( RegWEGd.Daten ) do
		for GeoKATDk, GeoKATDv in pairs( RegWEGd.Doppler ) do
			if GeoKATv[1] == GeoKATDv then
				RegWEGd.istschonda = true
			end
		end
		if RegWEGd.istschonda == false then
			table.insert( GeoKAT, GeoKATv )
			table.insert( RegWEGd.Doppler, GeoKATv[1] )
		end
		RegWEGd.istschonda = false
	end
	
	-- bei abgegangenem Bauwerk Doppler entfernen
	local ABE = { }     -- Speicher der Datensaetze
	--                           ['Nr'] = Satznummer
	--                           ['DS'] = Datensatz
	ABE[1] = { Nr = 0 } --    - 'Abgegangenes Bauwerk'
	ABE[2] = { Nr = 0 } --    - 'Bauwerk'
	
	for ABEk, ABEv in pairs( GeoKAT ) do
		if type( ABEk ) == "number" then
			if ABEv.Name == "Abgegangenes Bauwerk" then ABE[1] = { Nr = ABEk, DS = ABEv } end
			if ABEv.Name == "Bauwerk" then ABE[2] = { Nr = ABEk, DS = ABEv } end
		end
	end
	if (ABE[1]["Nr"] > 0 and ABE[2]["Nr"] > 0) then
		if ABE[1]["DS"][3] == ABE[2]["DS"][3] then GeoKAT[ABE[2]["Nr"]][3] = KATmax + 1 end
	end
	ABE = { { Nr = 0 }, { Nr = 0 } }
	for ABFk, ABFv in pairs( GeoKAT ) do
		if type( ABFk ) == "number" then
			if ABFv.Name == "Ehemaliger Gastronomiebetrieb" then ABE[1] = { Nr = ABFk, DS = ABFv } end
			if ABFv.Name == "Gastronomiebetrieb" then ABE[2] = { Nr = ABFk, DS = ABFv } end
		end
	end
	if (ABE[1]["Nr"] > 0 and ABE[2]["Nr"] > 0) then
		if ABE[1]["DS"][3] == ABE[2]["DS"][3] then GeoKAT[ABE[2]["Nr"]][3] = KATmax + 1 end
	end
	
	-- Rest-Kategorien finden
	local Rest = {
		Doppler = {}, --       Ablage der Nicht-Doppler
		istschonda = false, -- ist Eintrag schon vorhanden?
		istversteckt = 0 --    wenn versteckte kategorie, dann '-1'
	}
	
	KATText = KATText .. "\n# Rest-Kategorien"
	for KRSk, KRSv in pairs( Kategorien ) do
		Rest.istschonda = false
		Rest.istversteckt = 0
		if (KRSv[2] ~= "GeoN" and KRSv[2] ~= "GeoC") then
			for KRDk, KRDv in pairs( Rest.Doppler ) do
				if KRDv == KRSv[1] then Rest.istschonda = true end
			end
			if KRSv.Name == "istversteckt" then Rest.istversteckt = -1 end
			if Rest.istschonda == false then
				table.insert( GeoKAT, { KRSv[1], KRSv[2], Rest.istversteckt } )
				table.insert( Rest.Doppler, KRSv[1] )
				KATText = KATText .. "\n## { Rest.Doppler: „" .. tostring( KRSv[1] ) .. "“, KRSv[2]: „" .. tostring(  KRSv[2] ) .. "“, „" .. Rest.istversteckt .. "“ }"
			end
		end
	end
	
	-- Kategorien sortieren
	KATText = KATText .. "\n----\n;Kategorien sortiert\n:"
	local Kategorien = { } --                Kategorien zuruecksetzen
	--    KATmax                             Rxpansionstiege der Geo-Kategorien
	local ZL = { } --                        Maximalanzeiger
	ZL[1] = table.maxn( RegKAT ) --          maximal moegliche Geo-Expansionstiefe
	ZL[2] = table.maxn( DSZusatz.CSTADT ) -- Anzahl an Stadt-Kategorien
	
	KATText = KATText .. "KATmax: „" .. tostring( KATmax ) .. "“; ZL[1]: „" .. tostring( ZL[1] ) .. "“"
	if (KATmax < ZL[1] and DSZusatz.CSTADT[1] ~= "") then
		Kategorien[1] = { DSZusatz.CSTADT[ZL[2]], "GeoN" }
		KATText = KATText .. " / DSZusatz.CSTADT[ZL[2]] (DSZusatz.CSTADT[" .. ZL[2] .. "]): „" .. tostring( DSZusatz.CSTADT[ZL[2]] ) .. "“"
	end
	KATText = KATText .. " + "
	for KN = KATmax, -1, -1 do
		for KNk, KNv in pairs( GeoKAT ) do
			if type( KNk ) == "number" then
				if KNv[3] == KN then
					table.insert( Kategorien, KNv )
					KATText = KATText .. "\n* KNk (" .. KNk .. "): 1 = „" .. tostring( KNv[1] ) .. "“ + 2 = „" .. tostring( KNv[2] ) .. "“"
				end
			end
		end
	end
	KATText = KATText .. "\n----\n"
	
	return { Kategorien, KATText }
end

--	Kategorien['laufende Nummer']
--	[''][1]  = Name der Kategorie
--	[''][2]  = Sortierung der Kategorie = GeoN: nach 'NAME' der Infobox;
--	           GeoC + Cat: nach 'CAT_NAME' der Infobox;
--	           GeoN und GeoC werden nach Laender sortiert.
--	[''][3]  = Sofern Kategorisierungstyp Ablage
--	['Name'] = Name der Kategorie, z.B. 'VERWFernmelde'

-- Parameter-Uebersicht:
--	ModulStamm				= Stammverzeichnis des Moduls
--	SN						= Seitenname des Artikels
--	SR						= Basis-Seitenname des Artikels
--	SU						= Name der Unterseite des Artikels
--	SI						= Inhalt der Artikelseite
--	NNAME					= Ueberschrifts-Name der Infobox
--	CNAME					= Sortier-Name fuer Kategorien
--	DSZusatz.CSTADT         = Stadt-Name fuer Kategorien als Feld [1], [2], etc
--	Daten["WertZeile"]		= Werte aus Artikel in Daten einsortiert
--	Daten["WertSplit"]		= Daten splitten und als Tabelle abgelegt
--	Daten["WertSplitLink"]	= Verlinkte Daten
--	Daten["AnzSplit"]		= Anzahl der gesplitteten Datensaetze
--	Daten["BauTyp"]			= Typ des Bauwerkes (Liste, U3, etc.)
--	Daten["AnzLabel"]		= Daten-Bezeichner (Einzahl und Mehrzahl)
--	Typ						= Rueckgabewert ist der Name des Bauwerktyps (Auswahl mit TYP())
--	Geo						= Abfolgen der Kategoriebildung --> z.B. Sendeturm -- Turm -- Bauwerk
--	Bezeichner				= Zuordnung 'CAZ_TYP' zur Bezeichnung (z.B. Trum = Sendeturm)
--	Tabelle					= fuer die Infobox der Wiki-Code als Tabelle
--	OPK						= Zuordnungen der POSKARTE zu Obiger Karte
--	Kategorien				= Kategorien als Feldausdruck
--	DN[Typ]					= Datensatz um Daten nach Typ anzusprechen

-- Zusatz zur Datensatzbearbeitung
function Zusatz( frame, DatenWL )
	local NCC = CCN( SN, DatenWL, frame )
	local DSZusatz = {
		Geo = Geo,
		CSTADT = NCC.CSTADT,
		DSTADT = NCC.DSTADT,
		CNAME = NCC.CNAME,
		NNAME = NCC.NNAME,
		Bezeichner = Bezeichner,
		Tabelle = Tabelle,
		OPK = OPK,
		ModulStamm = ModulStamm,
		SN = SN,
		SR = SR,
		SU = SU,
		SI = SI,
		NSP = NSP,
		DatenWL = DatenWL
	}
	return DSZusatz
end

local p = {}
-- Anzeige Infobox
function p.Infobox( frame )
	local IB = ""
	
	-- Zuladen exportierter Datensaetze
	local Auflistung = require( ModulStamm .. "/Auflistung" )
	local Layout = require( ModulStamm .. "/Layout" )
	local Aufbereitung = require( ModulStamm .. "/Aufbereitung" )
	
	-- Vorbereiten der Datensaetze fuer 'Datensaetze aufbereiten'
	local REGION = Aufbereitung.DSFI( { }, frame )
	local DSZusatz = Zusatz( frame, { } )
	DSZusatz.Aufzaehlung = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle )
	DSZusatz.Aufzaehler = Auflistung.Aufzaehler( Daten, Geo, Bezeichner, Tabelle, Aufzaehlung )
	DSZusatz.Typ = TYP( Bezeichner, "", frame )
	DSZusatz.Aufbereitung = Aufbereitung
	DSZusatz.REGION = REGION
	
	-- Datensaetze aufbereiten
	local DSA = DS_Aufbereitung( DSZusatz, Daten, frame )
	Daten = DSA.Daten
	DN = DSA.DN
	Kategorien = DSA.Kategorien
	local K_Finder = KatFinder( DSZusatz, Daten, DN, Kategorien, frame )
	Kategorien = K_Finder[1]
	
	--Datensaetze anzeigen
	if (DSZusatz.SR ~= "Spielwiese" and DSZusatz.SU ~= "Spielwiese" and DSZusatz.SU ~= "Test" and DSZusatz.SU ~= "test") then DN.Test.BauTyp = "Ausblenden" end
	IB = IB .. Layout.InfoboxDarstellung( DSZusatz, Daten, DN, Kategorien, frame )
	IB = IB .. Wartung( DSZusatz, Daten, DN, Kategorien, frame )
	-- Test Spielwiese/KoordKarte
--	if (DSZusatz.SR == "Spielwiese" or DSZusatz.SU == "Spielwiese") then
--		local Spielwiese = require( DSZusatz.ModulStamm .. "/Test" )
--		IB = IB .. Spielwiese.KoordKarte( DSZusatz, Daten, DN, Kategorien, frame )
--	end
	IB = IB .. Layout.KategorieDarstellung( DSZusatz, Daten, DN, Kategorien, frame )
	
	return IB
end

-- Anzeige Fehlersuche
function p.Fehlersuche( frame )
	local IB = ""
	
	-- Zuladen exportierter Datensaetze
	local Auflistung = require( ModulStamm .. "/Auflistung" )
	local Layout = require( ModulStamm .. "/Layout" )
	local Aufbereitung = require( ModulStamm .. "/Aufbereitung" )
	
	-- Vorbereiten der Datensaetze fuer 'Datensaetze aufbereiten'
	local REGION = Aufbereitung.DSFI( { }, frame )
	local DSZusatz = Zusatz( frame, { } )
	DSZusatz.Aufzaehlung = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle )
	DSZusatz.Aufzaehler = Auflistung.Aufzaehler( Daten, Geo, Bezeichner, Tabelle, Aufzaehlung )
	DSZusatz.Typ = TYP( Bezeichner, "", frame )
	DSZusatz.Aufbereitung = Aufbereitung
	DSZusatz.REGION = REGION
	
	-- Datensaetze aufbereiten
	local DSA = DS_Aufbereitung( DSZusatz, Daten, frame )
	Daten = DSA.Daten
	DN = DSA.DN
	Kategorien = DSA.Kategorien
	local K_Finder = KatFinder( DSZusatz, Daten, DN, Kategorien, frame )
	Kategorien = K_Finder[1]
	
	--Datensaetze anzeigen
	IB = IB .. Layout.InfoboxDarstellung( DSZusatz, Daten, DN, Kategorien, frame )
	IB = IB .. Layout.KategorieDarstellung( DSZusatz, Daten, DN, Kategorien, frame )
	IB = IB .. K_Finder[2]
	
	return IB
end

-- Anzeige Infobox als Nebenbox
function p.Nebenbox( frame )
	local NB = ""
	
	-- Zuladen exportierter Datensaetze
	local Auflistung = require( ModulStamm .. "/Auflistung" )
	local Layout = require( ModulStamm .. "/Layout" )
	local Aufbereitung = require( ModulStamm .. "/Aufbereitung" )
	
	-- Vorbereiten der Datensaetze fuer 'Datensaetze aufbereiten'
	local REGION = Aufbereitung.DSFI( { }, frame )
	local DSZusatz = Zusatz( frame, { } )
	DSZusatz.Aufzaehlung = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle )
	DSZusatz.Aufzaehler = Auflistung.Aufzaehler( Daten, Geo, Bezeichner, Tabelle, Aufzaehlung )
	DSZusatz.Typ = TYP( Bezeichner, "", frame )
	DSZusatz.Aufbereitung = Aufbereitung
	DSZusatz.REGION = REGION
	
	-- Datensaetze aufbereiten
	local DSA = DS_Aufbereitung( DSZusatz, Daten, frame )
	Daten = DSA.Daten
	DN = DSA.DN
	Kategorien = DSA.Kategorien
	local K_Finder = KatFinder( DSZusatz, Daten, DN, Kategorien, frame )
	Kategorien = K_Finder[1]
	
	--Datensaetze anzeigen
	if (DSZusatz.SR ~= "Spielwiese" and DSZusatz.SU ~= "Spielwiese" and DSZusatz.SU ~= "Test" and DSZusatz.SU ~= "test") then DN.Test.BauTyp = "Ausblenden" end
	if not DN.BILD.WertSplit[1] then DN.IBBild.BauTyp = "Ausblenden" end
	DN.KoordKarte.BauTyp = "Zeile"
	DN.POSKARTE.BauTyp = "Ausblenden"
	NB = NB .. Layout.InfoboxDarstellung( DSZusatz, Daten, DN, Kategorien, frame )
	
	return NB
end

-- Anzeige Weiterleitung
function p.Weiterleitung( frame )
	local WL = ""
	
	-- Zuladen exportierter Datensaetze
	local Auflistung = require( ModulStamm .. "/Auflistung" )
	local Layout = require( ModulStamm .. "/Layout" )
	local Aufbereitung = require( ModulStamm .. "/Aufbereitung" )
	
	-- Vorbereiten der Datensaetze fuer 'Datensaetze aufbereiten'
	local DatenWL = Aufbereitung.DatenWeiterleitung( Daten, frame )
	if (DatenWL[1] == false and NSP == 0) then
		WL = WL .. "<div class=\"error\">[[Vorlage:Infobox Sendeanlage/Wartung/Weiterleitungslink defekt|Weiterleitungslink defekt]]</div>"
	end
	DatenWL[1] = nil
	local REGION = Aufbereitung.DSFI( DatenWL, frame )
	local DSZusatz = Zusatz( frame, DatenWL )
	DSZusatz.Aufzaehlung = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle )
	DSZusatz.Aufzaehler = Auflistung.Aufzaehler( Daten, Geo, Bezeichner, Tabelle, Aufzaehlung )
	DSZusatz.Typ = TYP( Bezeichner, DSZusatz.DatenWL.CAT_TYP, frame )
	DSZusatz.Aufbereitung = Aufbereitung
	DSZusatz.REGION = REGION
	
	-- Datensaetze aufbereiten
	local DSA = DS_Aufbereitung( DSZusatz, Daten, frame )
	Daten = DSA.Daten
	DN = DSA.DN
	Kategorien = DSA.Kategorien
	local K_Finder = KatFinder( DSZusatz, Daten, DN, Kategorien, frame )
	Kategorien = K_Finder[1]
	
	--Datensaetze anzeigen
	if DatenWL.ZIEL then WL = WL .. tostring( DN.KoordKarte.WertZeile ) end
	WL = WL .. Wartung( DSZusatz, Daten, DN, Kategorien, frame )
	if NSP == 0 then WL = WL .. Layout.KategorieDarstellung( DSZusatz, Daten, DN, Kategorien, frame ) end
	
	-- Test Spielwiese/DatenSeite
	if (DSZusatz.SR == "Spielwiese" or DSZusatz.SU == "Spielwiese") then
		local Spielwiese = require( DSZusatz.ModulStamm .. "/Test" )
		WL = Spielwiese.DatenSeite( DSZusatz, Daten, DN, Kategorien, frame )
	end
	
	return WL
end

-- Anzeige Dokumentation Infobox ueber DokuTemplate
function p.Dokumentation( frame )
	local Dokumentation = mw.getCurrentFrame():getParent().args[1] or frame.args[1] or "DokuVorlage"
	
	-- Zuladen exportierter Datensaetze
	local Auflistung = require( ModulStamm .. "/Auflistung" )
	local Layout = require( ModulStamm .. "/Layout" )
	
	-- Vorbereiten der Datensaetze fuer 'Datensaetze aufbereiten'
	local DSZusatz = Zusatz( frame, { } )
	DSZusatz.Aufzaehlung = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle )
	DSZusatz.Layout = Layout.Layout()
	
	-- Zusatz fuer diverse Funktionen
	if Dokumentation == "DokuDaten" then
		local Aufbereitung = require( ModulStamm .. "/Aufbereitung" )
		DSZusatz.Aufbereitung = Aufbereitung
		DSZusatz.Aufzaehler = Auflistung.Aufzaehlung( Daten, Geo, Bezeichner, Tabelle, DSZusatz.Aufzaehlung )
		DSZusatz.REGION = Aufbereitung.DSFI( { }, frame )
		Aufbereitung = DS_Aufbereitung( DSZusatz, Daten, frame )
		Daten = Aufbereitung["Daten"]
	end
	
	local VZ = require( ModulStamm .. "/VorlageDokumentation" )
	return VZ[Dokumentation]( DSZusatz, Daten, frame )
end

return p