| Vorlagenprogrammierung | Diskussionen | Lua | Test | Unterseiten | ||
| Modul | Deutsch
|
Modul: | Dokumentation | |||
Diese Seite enthält Code in der Programmiersprache Lua. Einbindungszahl Cirrus
-- Auslesen der Deteils zu Regionen ueber Wiki-Vorlage
function REG( Level, Info, DatenWL, frame )
--[[ Rueckgabewert erzeugt 'Info ISO-3166-2' fuer den Parser. Muster:
- REG2: '{{Info ISO-3166-2|code={{{REGION-ISO|}}}|name}}'
- REG1: '{{Info ISO-3166-2|code={{Info ISO-3166-2|code={{{REGION-ISO|}}}|upper}}|name}}'
- REG0: '{{Info ISO-3166-2|code={{Info ISO-3166-2|code={{{REGION-ISO|}}}|top}}|name}}'
]]
local VR = {
REGION_ISO = { I = mw.getCurrentFrame():getParent().args["REGION-ISO"] },
title = "Info ISO-3166-2"
}
if (VR.REGION_ISO.I == "" or VR.REGION_ISO.I == nil) then VR.REGION_ISO.I = frame.args["REGION-ISO"] end
if (VR.REGION_ISO.I == "" or VR.REGION_ISO.I == nil) then VR.REGION_ISO.I = DatenWL["REGION-ISO"] end
if VR.REGION_ISO.I == "" then VR.REGION_ISO.I = nil end
VR.code = { II = VR.REGION_ISO.I }
VR.code.Y = { O = "top", I = "upper" }
VR.code.X = VR.code.Y[Level] or ""
VR.code.I = frame:expandTemplate{ title = "Info ISO-3166-2", args = { VR.code.X, code = VR.code.II } }
VR.code.O = VR.code.I
VR.args = {
Info,
code = VR.code[Level]
}
return frame:expandTemplate{ title = VR.title, args = VR.args }
end
-- Zaehlung, wie viele Parameter vorhanden sind
function ZDS( ZG, Zmax )
local Aussage = false
local max = 0
for ZGk, ZGv in pairs( ZG ) do
if ZGv[2] then max = max + 1 end
end
if max > Zmax then Aussage = true end
return Aussage
end
local p = {}
-- Ausgabe einer Fehlermeldung
p.Fehler = function ( Meldung )
local Text = tostring( Meldung ) or "\'\'Fehlertext fehlt!\'\'"
local Anzeige = mw.html.create( "div" )
:attr( "class", "error rahmenfarbe3 hintergrundfarbe8" )
:css( "font-size", "120%" )
:css( "font-weight", "bold" )
:css( "text-align", "center" )
:css( "border-style", "solid" )
:css( "border-width", "2px" )
:css( "padding", ".5em" )
:css( "margin", ".25em" )
:wikitext( Text )
return tostring( Anzeige )
end
-- Anzeige Rahmen
p.Rahmen = function ( TXT, Ue )
local LA = { { " rahmenfarbe2", " border-width:1px; border-style:solid;", "" }, { "", "", "\n! colspan=\"2\" class=\"hintergrundfarbe9\" style=\"text-align:center;\" | " .. tostring( Ue ) } }
local Text = { { "Anzuzeigende Eigenschaft", "Anzuzeigender Text" } }
local Einheit = ""
local Un = 1
if Ue then Un = 2 end
if type( TXT ) == "table" then Text = TXT end
local Inhalt = "\n{| class=\"toptextcells" .. LA[Un][1] .. "\" style=\"font-size:90%; text-align:left; width:90%; margin:0em auto;" .. LA[Un][2] .. "\"" .. LA[Un][3]
for TXTi, TXTv in pairs(Text) do
if (type( TXTv ) == "table" ) then
if (TXTv[2] and TXTv[2] ~= "") then
Einheit = TXTv[3] or ""
Inhalt = Inhalt .. "\n|-\n| " .. tostring( TXTv[1] ) .. ":\n| " .. tostring( TXTv[2] .. Einheit )
end
end
end
Inhalt = Inhalt .. "\n|}\n"
return Inhalt
end
-- Werte aus Artikel in Daten einsortieren und splitten
p.AufarbStand = function ( Datensatz, DSZusatz, Kategorie, frame )
local DS = Datensatz -- zu bearbeitender Datensatz
local Kategorien = Kategorie -- Speicher fuer Kategorien
DS.TMP = { } -- temporaerer Speicher
DS.WertZeile = mw.getCurrentFrame():getParent().args[DS.Name]
if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = frame.args[DS.Name] end
if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DSZusatz.DatenWL[DS.Name] end
if DS.Standard then
if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DS.Standard[DSZusatz.Typ] end
if (DS.WertZeile == "" or DS.WertZeile == nil) then DS.WertZeile = DS.Standard[1] end
end
if DS.WertZeile == nil then DS.WertZeile = "" end
DS.WertSplit = mw.text.split( DS.WertZeile, "/" )
if DS.WertZeile == "" then DS.WertZeile = nil end
if DS.WertSplit[1] == "" then DS.WertSplit[1] = nil end
DS.AnzSplit = table.maxn( DS.WertSplit )
-- Auswahl der Bezeichnung 'Typ' zu 'BauTyp'
DS.TMP.Z = DS.Typ or { "Zeile" }
DS.BauTyp = DS.TMP.Z[DSZusatz.Typ] or DS.TMP.Z[1]
-- Textverlinkung und Einheitsanbindung
DS.TMP.EHT = { "", "" } -- Formatierung der Einheiten zur Wiedergabe
DS.TMP.LIZ = "" -- resultierende Einheiten(-verlinkung)
DS.TMP.LTR = DSZusatz.Aufzaehler[DS.BauTyp] or "/" -- Trennzeichen bei Aufsplittung
DS.TMP.AFZ = DSZusatz.Aufzaehlung[DS.Name] or { } -- Aufzaehlung
DS.TMP.Liste = "" -- Auflistung der Werte
DS.TMP.AZ = { } -- Aufzaehler als Tabelle aller, z.B. 'VERW'
DS.TMP.WSL = { } -- WertSplitLink als Tabelle
-- Einheiten-Auswaehler
if DS.Einheit then
if (type( DS.Einheit[1] ) == "string" and DS.Einheit[1] ~= "") then
DS.TMP.EHT[1] = " " .. DS.Einheit[1]
DS.TMP.EHT[2] = DS.TMP.EHT[1]
if (type( DS.Einheit[2] ) == "string" and DS.Einheit[2] ~= "") then
DS.TMP.EHT[2] = " [[" .. DS.Einheit[2] .. "|" .. DS.Einheit[1] .. "]]"
end
end
end
-- Durchlauf Zaehlinstanz
for j, ZS in pairs(DS.WertSplit) do
-- Standardsetzung entsprechend Bauwerktyp
DS.TMP.tf = true
if DS.TMP.AFZ[ZS] then
DS.TMP.AFZ[ZS][1] = DS.TMP.AFZ[ZS][1] or { }
DS.TMP.AFZ[ZS][2] = DS.TMP.AFZ[ZS][2] or { }
DS.TMP.AFZ[ZS][3] = DS.TMP.AFZ[ZS][3] or { }
DS.TMP.AFZ[ZS][4] = DS.TMP.AFZ[ZS]["CatTyp"] or { }
if DS.TMP.AFZ[ZS][1][DSZusatz.Typ] == false then DS.TMP.tf = false end
end
if DS.TMP.tf == false then DS.TMP.AFZ[ZS] = nil end
-- Durchzaehler fuer Werte in VERW + T_HOCH etc.
if DS.TMP.AFZ[ZS] then
DS.TMP.STAZ = { "\'\Wert unbekannt\'\'", "\'\Wert unbekannt\'\'" }
for k=1, 4, 1 do -- Ermittlung Standardwerte
DS.TMP.STAZ[k] = DS.TMP.AFZ[ZS][k][DSZusatz.Typ] or DS.TMP.AFZ[ZS][k][1]
end
if (type( DS.TMP.STAZ[3] ) == "string" and DS.TMP.STAZ[3] ~= "" ) then
table.insert( Kategorien, { DS.TMP.STAZ[3], DS.TMP.AFZ[ZS]["Geo"], DS.TMP.STAZ[4], Name = DS.Name .. DS.TMP.STAZ[1] } )
end
DS.TMP.AZ[j] = DS.TMP.STAZ
else
DS.TMP.AZ[j] = { ZS, ZS, nil }
end
if j < 2 then
DS.TMP.LIZ = DS.TMP.EHT[2]
else
DS.TMP.Liste = DS.TMP.Liste .. DS.TMP.LTR
DS.TMP.LIZ = DS.TMP.EHT[1]
end
if DS.WertZeile then DS.TMP.Liste = DS.TMP.Liste .. DS.TMP.AZ[j][2] .. DS.TMP.LIZ end
DS.TMP.WSL[j] = DS.TMP.AZ[j][2]
end
DS.WertSplitLink = DS.TMP.WSL
if DSZusatz.Aufzaehler[DS.BauTyp] then DS.WertZeile = DS.TMP.Liste end
if DS.WertZeile == "" then DS.WertZeile = nil end
-- Eigenschaften beschriften (Einzahl / Mehrzahl / Typ)
DS.TMP.EW = DS.Label -- Eigenschaften-Werte
if DS.TMP.EW then
DS.TMP.EW = DS.Label[DSZusatz.Typ]
if not DS.TMP.EW then DS.TMP.EW = DS.Label[1] end
if not DS.TMP.EW then DS.TMP.EW = { "" } end
DS.TMP.EW[2] = DS.TMP.EW[2] or DS.TMP.EW[1]
if DS.AnzSplit > 1 then
DS.AnzLabel = DS.TMP.EW[2]
else
DS.AnzLabel = DS.TMP.EW[1]
end
else
DS.AnzLabel = ""
end
DS.TMP = nil
return { DS = DS, Kategorien = Kategorien }
end
p.DSIB = {}
-- NAME Festlegen
p.DSIB.NAME = function ( DN, DSZusatz, Kategorien, frame )
DN.NAME.WertZeile = DSZusatz.NNAME
return DN
end
-- Ueberschrift der Infobox
p.DSIB.UE1 = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = {}
DSMB.Bezeichner = mw.html.create( "div" )
:css( "width", "100%" )
:wikitext( DN.NAME.WertZeile )
DSMB[1] = tostring( DSMB.Bezeichner )
DSMB.Bezeichner = mw.html.create( "div" )
:css( "font-size", "90%" )
:css( "width", "100%" )
:wikitext( tostring( DN.OFZ_NAME.WertZeile ) )
DSMB[2] = tostring( DSMB.Bezeichner )
DSMB.Bezeichner = mw.html.create( "div" )
:css( "font-size", "70%" )
:css( "font-style", "italic" )
:css( "width", "100%" )
:wikitext( tostring( DN.FUNK_NAME.WertZeile ) )
DSMB[3] = tostring( DSMB.Bezeichner )
if not DN.OFZ_NAME.WertZeile then DSMB[2] = nil end
if not DN.FUNK_NAME.WertZeile then DSMB[3] = nil end
if not DSMB[2] then
DSMB[2] = DSMB[3]
DSMB[3] = nil
end
DN.UE1.WertSplit = { DSMB[1], DSMB[2], DSMB[3] }
DN.UE1.AnzSplit = table.maxn( DN.UE1.WertSplit )
DN.UE1.WertZeile = ""
for DSMBk, DSMBv in pairs( DN.UE1.WertSplit ) do
DN.UE1.WertZeile = DN.UE1.WertZeile .. DSMBv
end
return DN
end
-- Anzeige Bild
p.DSIB.IBBild = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { BILD = { }, TMP = { } }
DSMB.BILD = {
Bmax = 360,
Hmax = 500,
Amax = 48000,
Titel = ""
}
DSMB.BILD.Datei = DN.BILD.WertZeile or "kein Bild"
DSMB.BILD.Datei = DSMB.BILD.Datei:gsub("[%[%]]", "")
DSMB.BILD.Beschreibung = DN.BILD_BES.WertZeile or ""
if mw.title.new( DSMB.BILD.Datei, 6 ) then
DSMB.BILD.B = mw.title.new( DSMB.BILD.Datei, 6 ).file.width
DSMB.BILD.H = mw.title.new( DSMB.BILD.Datei, 6 ).file.height
end
DN.TMP_KAT = { } -- Zwischenspeicher fuer Kategorien
-- Bilderwunsch aus Wiki-Vorlage generieren
DSMB.BW = {
title = "Bilderwunsch/encode",
args = {
Ort = DN.ORT.WertZeile,
Name = DSZusatz.NNAME,
KoordLat = "",
KoordLon = ""
}
}
if (type(DN.NS.WertZeile) == "string" and type(DN.NS.WertSplit[1]) == "number") then DSMB.BW.args.KoordLat = tostring( DN.NS.WertSplit[1] ) end
if (type(DN.EW.WertZeile) == "string" and type(DN.EW.WertSplit[1]) == "number") then DSMB.BW.args.KoordLon = tostring( DN.EW.WertSplit[1] ) end
DSMB.BILDERWUNSCH = frame:expandTemplate{ title = DSMB.BW.title, args = DSMB.BW.args } or ""
-- 'WertZeile' bereitstellen
if (DN.BILD.WertZeile == "kein" or DN.BILD.WertZeile == "keine" or DN.BILD.WertZeile == "nein" or DN.BILD.WertZeile == "no" or DN.BILD.WertZeile == "none" or DN.BILD.WertZeile == "aus" or DN.BILD.WertZeile == "ohne") then
table.insert( DN.TMP_KAT, { "Wikipedia:Bilderwunsch unterdrückt", Name = "istversteckt" } )
elseif (not DN.BILD.WertZeile and not DN.ABR_DEKADE.WertZeile ) then
DN.IBBild.WertZeile = "[[Datei:Photo-request.svg|64px|link=Wikipedia:Bilderwünsche/Anleitung]]<br />[[Wikipedia:Bilderwünsche/Anleitung|Bild gesucht]]"
if DSZusatz.NSP == 0 then DN.IBBild.WertZeile = DN.IBBild.WertZeile .. "\n" .. DSMB.BILDERWUNSCH end
elseif not (DSMB.BILD.B and DSMB.BILD.H) then
if not DN.ABR_DEKADE.WertZeile then DN.IBBild.WertZeile = DSZusatz.Aufbereitung.Fehler( "Angegebene Bilddatei „" .. DSMB.BILD.Datei .. "“ ist nicht verfügbar." ) end
elseif DN.BILD.WertZeile then
DSMB.BILD.A = DSMB.BILD.B * DSMB.BILD.H -- Flaeche
DSMB.BILD.SV = DSMB.BILD.B / DSMB.BILD.H -- Seitenverhaeltnis
DSMB.BILD.Borg = math.sqrt( DSMB.BILD.Amax * DSMB.BILD.SV ) -- Breite gem. SV
DSMB.BILD.Horg = DSMB.BILD.Borg / DSMB.BILD.SV -- Hoehe gem. SV
if DSMB.BILD.Borg > DSMB.BILD.Bmax then
DSMB.BILD.BBild = DSMB.BILD.Bmax
DSMB.BILD.HBild = DSMB.BILD.BBild / DSMB.BILD.SV
elseif DSMB.BILD.Horg > DSMB.BILD.Hmax then
DSMB.BILD.HBild = DSMB.BILD.Hmax
DSMB.BILD.BBild = DSMB.BILD.HBild * DSMB.BILD.SV
else
DSMB.BILD.BBild = DSMB.BILD.Borg
DSMB.BILD.HBild = DSMB.BILD.Horg
end
DSMB.BILD.BBild = math.floor( DSMB.BILD.BBild )
DSMB.BILD.HBild = math.floor( DSMB.BILD.HBild )
-- Anpassung Titel
DSMB.TMP.html = {
{ "<br />", " " },
{ "<small>", "" },
{ "</small>", "" }
}
DSMB.BILD.Titel = DSMB.BILD.Beschreibung
if DSMB.BILD.Titel == "" then DSMB.BILD.Titel = "Datei:" .. DSMB.BILD.Datei end
for HTMLk, HTMLv in pairs( DSMB.TMP.html ) do
DSMB.TMP.Text = ""
DSMB.TMP.Split = mw.text.split( DSMB.BILD.Titel, HTMLv[1] )
for BITk, BITv in pairs( DSMB.TMP.Split ) do
if BITk > 1 then DSMB.TMP.Text = DSMB.TMP.Text .. HTMLv[2] end
DSMB.TMP.Text = DSMB.TMP.Text .. BITv
end
DSMB.BILD.Titel = DSMB.TMP.Text
end
-- Anzeige des Bildes
DSMB.Anzeige = mw.html.create( "div" )
:css( "font-size", "85%" )
:wikitext( "[[Datei:" .. DSMB.BILD.Datei .. "|" .. DSMB.BILD.BBild .. "x" .. DSMB.BILD.HBild .. "px|center|" .. DSMB.BILD.Titel .. "|alt=Bild des Objektes]]" .. DSMB.BILD.Beschreibung )
DN.IBBild.WertZeile = tostring( DSMB.Anzeige )
end
return DN
end
-- Regionen
p.DSIB.Regionen = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = ""
if DSZusatz.REGION["0"] then
DN.REGION_0.WertZeile = "[[" .. DSZusatz.REGION["0"]["lemma"] .. "|" .. DSZusatz.REGION["0"]["name"] .. "]]"
else
DN.REGION_0.BauTyp = "Feld"
DN.REGION_0.AnzLabel = ""
if DN["REGION-ISO"]["WertZeile"] then
DSMB = "Es ist ein falscher"
else
DSMB = "Es ist kein"
end
DN.REGION_0.WertZeile = DSZusatz.Aufbereitung.Fehler( DSMB .. " Wert für den Parameter „REGION-ISO“ eingetragen!<br />→ [[ISO-3166-1-Kodierliste|siehe Kodierliste]]" )
end
if DSZusatz.REGION["1"] then
DN.REGION_1.AnzLabel = DSZusatz.REGION["1"]["admtype"]
DN.REGION_1.WertZeile = "[[" .. DSZusatz.REGION["1"]["lemma"] .. "|" .. DSZusatz.REGION["1"]["name"] .. "]]"
end
if DSZusatz.REGION["2"] then
DN.REGION_2.AnzLabel = DSZusatz.REGION["2"]["admtype"]
DN.REGION_2.WertZeile = "[[" .. DSZusatz.REGION["2"]["lemma"] .. "|" .. DSZusatz.REGION["2"]["name"] .. "]]"
end
return DN
end
-- Hoehenlage
p.DSIB.LAGEPUNKT = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = DN.LAGEPUNKT.WertZeile or ""
DN.LAGEPUNKT.WertSplit[1] = tonumber( DN.LAGEPUNKT.WertSplit[1] ) or DN.LAGEPUNKT.WertSplit[1]
if not DN.LAGEPUNKT.WertSplit[2] then
if DSZusatz.REGION["0"] then
DN.LAGEPUNKT.WertSplit[2] = DSZusatz.REGION["0"]["acronym"]
else
DN.LAGEPUNKT.WertSplit[2] = ""
end
end
if DN.LAGEPUNKT.WertSplit[2] == "CH" then DN.LAGEPUNKT.WertSplit[2] = "CH-m" end
if DN.LAGEPUNKT.WertSplit[2] == "LI" then DN.LAGEPUNKT.WertSplit[2] = "LI-m" end
DN.LAGEPUNKT.WertZeile = frame:expandTemplate{ title = "Höhe", args = { tostring( DN.LAGEPUNKT.WertSplit[1] ), DN.LAGEPUNKT.WertSplit[2] } }
if DSMB == "" then DN.LAGEPUNKT.WertZeile = nil end
if DN.LAGEPUNKT.WertSplit[2] == "" then DN.LAGEPUNKT.WertSplit[2] = nil end
return DN
end
-- Zugaenglichkeit
p.DSIB.ZUGANG = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = DSZusatz.Bezeichner[DSZusatz.Typ] or DSZusatz.Bezeichner[DSZusatz.Bezeichner[1]]
if DN.ZUGANG.WertZeile == "ja" then
DN.ZUGANG.WertZeile = DSMB .. " öffentlich zugänglich"
elseif DN.ZUGANG.WertZeile == "jein" then
DN.ZUGANG.WertZeile = DSMB .. " nach Voranmeldung zugänglich"
elseif DN.ZUGANG.WertZeile == "nein" then
DN.ZUGANG.WertZeile = DSMB .. " öffentlich nicht zugänglich"
end
if ( DN.ABR_DEKADE.WertZeile and DSZusatz.Typ ~= "Anlage") then DN.ZUGANG.BauTyp = "Ausblenden" end
return DN
end
-- Zusammenfassung fuer Turmbau
p.DSIB.IBTBau = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { }
DSMB.Tabelle = {
{ DN.T_BAU_KOST.AnzLabel, DN.T_BAU_KOST.WertZeile },
{ DN.T_BAU_HERR.AnzLabel, DN.T_BAU_HERR.WertZeile },
{ DN.T_BAU_ARCH.AnzLabel, DN.T_BAU_ARCH.WertZeile },
{ DN.T_BAU_ST.AnzLabel, DN.T_BAU_ST.WertZeile }
}
if DN.T_BAU_ZEIT.WertZeile then
DN.IBTBau.ausklappen = "Weitere Baudaten"
else
DN.IBTBau.AnzLabel = "Baudaten:"
end
DSMB.Anzeige = ZDS( DSMB.Tabelle, 1 )
if DSMB.Anzeige == true then
DN.IBTBau.WertZeile = DSZusatz.Aufbereitung.Rahmen( DSMB.Tabelle )
DN.T_BAU_KOST.BauTyp = "Ausblenden"
DN.T_BAU_HERR.BauTyp = "Ausblenden"
DN.T_BAU_ARCH.BauTyp = "Ausblenden"
DN.T_BAU_ST.BauTyp = "Ausblenden"
else
DN.IBTBau.BauTyp = "Ausblenden"
end
return DN
end
-- Zusammenfassung fuer Turm-Einzelhoehen
p.DSIB.IBTHoch = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { }
DSMB.Tabelle = {
{ DN.T_HOCH_AUS.AnzLabel, DN.T_HOCH_AUS.WertZeile },
{ DN.T_HOCH_RES.AnzLabel, DN.T_HOCH_RES.WertZeile },
{ DN.T_HOCH_BET.AnzLabel, DN.T_HOCH_BET.WertZeile }
}
if DN.T_HOCH_GES.WertZeile then
DN.IBTHoch.ausklappen = "Weitere Höhenwerte"
else
DN.IBTHoch.AnzLabel = "Höhenwerte im Detail:"
end
DSMB.Anzeige = ZDS( DSMB.Tabelle, 1 )
if DSMB.Anzeige == true then
DN.IBTHoch.WertZeile = DSZusatz.Aufbereitung.Rahmen( DSMB.Tabelle )
DN.T_HOCH_AUS.BauTyp = "Ausblenden"
DN.T_HOCH_RES.BauTyp = "Ausblenden"
DN.T_HOCH_BET.BauTyp = "Ausblenden"
else
DN.IBTHoch.BauTyp = "Ausblenden"
end
return DN
end
-- Zusammenfassung fuer Sendeanlagen-Einzelheiten
p.DSIB.IBSHoch = function ( DN, DSZusatz, Kategorien, frame )
DN.IBSHoch.ausklappen = "Daten zu den einzelnen Sendetürmen/Sendemasten"
local DSMB = { }
DSMB.Tabelle = {
{ "Höhe", DN.S_HOCH_GES.WertZeile, DN.S_HOCH_GES.WertSplit, DN.S_HOCH_GES.AnzSplit, Name = "S_HOCH_GES", Einheit = " m" },
{ "Bauzeit", DN.S_BAU_ZEIT.WertZeile, DN.S_BAU_ZEIT.WertSplit, DN.S_BAU_ZEIT.AnzSplit, Name = "S_BAU_ZEIT" },
{ "Betriebszeit", DN.S_BET_ZEIT.WertZeile, DN.S_BET_ZEIT.WertSplit, DN.S_BET_ZEIT.AnzSplit, Name = "S_BET_ZEIT" },
{ "Umbau Antenne", DN.S_ANT_BAU.WertZeile, DN.S_ANT_BAU.WertSplit, DN.S_ANT_BAU.AnzSplit, Name = "S_ANT_BAU" },
{ "Umbau Sender", DN.S_UMBAU.WertZeile, DN.S_UMBAU.WertSplit, DN.S_UMBAU.AnzSplit, Name = "S_UMBAU" },
{ "Stilllegung Sender", DN.S_STILL.WertZeile, DN.S_STILL.WertSplit, DN.S_STILL.AnzSplit, Name = "S_STILL" }
}
-- Maximale Datensatz-Anzahl:
DSMB.max = 0 -- Ermittlung maximale Turmanzahl, Einzel
DSMB.SatzMax = 0 -- Ermittlung maximale Turmanzahl, Gesamt
for maxK, maxV in pairs( DSMB.Tabelle ) do
if maxV[2] == "" then DSMB.max = 0 else DSMB.max = maxV[4] end
DSMB.SatzMax = math.max( DSMB.SatzMax, DSMB.max )
end
-- Sortierung nach Turm/Mast:
local Einheit = ""
DSMB.Komplett = { } -- Komplett-Zusammenstellung nach Turm/Mast
DSMB.leer = "style=\"text-align:center;\" | –"
for ZZ=1, DSMB.SatzMax, 1 do
DSMB.Komplett[ZZ] = { }
for ZZk, ZZv in pairs( DSMB.Tabelle ) do
Einheit = ZZv.Einheit or ""
DSMB.Komplett[ZZ][ZZk] = { ZZv[1], DSMB.leer, Einheit }
if ZZv[3] == nil then ZZv[3] = { } end
if (ZZv[3][ZZ] and ZZv[3][ZZ] ~= "") then DSMB.Komplett[ZZ][ZZk][2] = ZZv[3][ZZ] end
end
end
-- Leere erkennen
DSMB.Grundsatz = { }
DSMB.Box = false
DSMB.DSHoch = 1
for dslMk, dslMv in pairs( DSMB.Tabelle ) do
if dslMv["Name"] == "S_HOCH_GES" then DSMB.DSHoch = dslMk end
if (DN[dslMv["Name"]]["WertZeile"] and DN[dslMv["Name"]]["BauTyp"] == "Liste" and (DSMB.Tabelle[dslMk][4] > 1 or dslMv["Name"] == "S_HOCH_GES")) then
DSMB.Grundsatz[dslMk] = true
if dslMv["Name"] ~= "S_HOCH_GES" then
DN[dslMv["Name"]]["BauTyp"] = "Ausblenden"
DSMB.Box = true
end
else
DSMB.Grundsatz[dslMk] = false
end
end
if (DSMB.Box == false or DN[DSMB.Tabelle[DSMB.DSHoch]["Name"]]["BauTyp"] ~= "Liste") then
DSMB.Grundsatz[DSMB.DSHoch] = false
else
DN[DSMB.Tabelle[DSMB.DSHoch]["Name"]]["BauTyp"] = "Ausblenden"
end
for ZX=1, DSMB.SatzMax, 1 do -- leere aussortieren
for ZXk, ZXv in pairs( DSMB.Komplett[ZX] ) do
if DSMB.Grundsatz[ZXk] == false then ZXv[2] = nil end
end
end
-- Liste anzeigen:
if DSMB.Box == true then
DN.S_ANZAHL_T.BauTyp = "Ausblenden"
for XX=1, DSMB.SatzMax, 1 do
if XX == 1 then
DN.IBSHoch.WertZeile = ""
else
DN.IBSHoch.WertZeile = DN.IBSHoch.WertZeile .. "\n"
end
DN.IBSHoch.WertZeile = DN.IBSHoch.WertZeile .. DSZusatz.Aufbereitung.Rahmen( DSMB.Komplett[XX], "Turm/Mast " .. tostring( XX ) )
end
else
DN.IBSHoch.BauTyp = "Ausblenden"
end
if DN.IBSHoch.WertZeile == "" then DN.IBSHoch.WertZeile = nil end
return DN
end
-- Gueltigkeitspruefung 'KOORDINATEN'
p.DSIB.KOORDINATEN = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { }
DSMB.KO = { { "NS", P = "N", N = "S" } , { "EW", P = "E", N = "W" } }
DSMB.ZeilenSpeicher = { }
DSMB.ist = { NS = true, EW = true }
for KONk, KONv in pairs( DSMB.KO ) do
DSMB.ZeilenSpeicher.Komma = 0
for WKk, WKv in pairs( DN[KONv[1]]["WertSplit"] ) do
if (tonumber( WKv ) and WKk < 4 ) then
DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma + tonumber( WKv ) / (60 ^ ( WKk - 1 ))
elseif ( WKv == KONv.P and WKk > 1 and WKk < 5 ) then
DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma * 1
elseif ( WKv == KONv.N and WKk > 1 and WKk < 5 ) then
DSMB.ZeilenSpeicher.Komma = DSMB.ZeilenSpeicher.Komma * -1
else
DSMB.ist[KONv[1]] = false
end
end
if not DN[KONv[1]]["WertSplit"][1] then DSMB.ist[KONv[1]] = false end
if DSMB.ist[KONv[1]] == true then
if ( (DSMB.ZeilenSpeicher.Komma * 10^8 - math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 )) * 10 ) < 5 then
DSMB.ZeilenSpeicher.Komma = math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 ) / ( 10^8 )
else
DSMB.ZeilenSpeicher.Komma = math.floor( DSMB.ZeilenSpeicher.Komma * 10^8 + 1 ) / ( 10^8 )
end
if (( DSMB.ZeilenSpeicher.Komma > 90 * KONk) or ( DSMB.ZeilenSpeicher.Komma < -90 * KONk) ) then DSMB.ist[KONv[1]] = false end
DN[KONv[1]]["WertSplit"][1] = DSMB.ZeilenSpeicher.Komma
DN[KONv[1]]["AnzSplit"] = 1
if DSMB.ist[KONv[1]] == true then
DN[KONv[1]]["WertZeile"] = tostring( DSMB.ZeilenSpeicher.Komma )
else
DN[KONv[1]]["WertZeile"] = nil
end
else
DN[KONv[1]]["WertSplit"][1] = DN[KONv[1]]["WertZeile"]
DN[KONv[1]]["WertZeile"] = nil
DN[KONv[1]]["AnzSplit"] = 1
end
if not DN[KONv[1]]["WertSplit"][1] then DN[KONv[1]]["AnzSplit"] = 0 end
end
return DN
end
-- Positionskarte 'POSKARTE'
p.DSIB.POSKARTE = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { Karte = { }, TMP = { } }
if (DN.POSKARTE.WertZeile == "kein" or DN.POSKARTE.WertZeile == "keine" or DN.POSKARTE.WertZeile == "nein" or DN.POSKARTE.WertZeile == "no" or DN.POSKARTE.WertZeile == "aus" or DN.POSKARTE.WertZeile == "ohne") then
DSMB.anzeigen = false
else
DSMB.anzeigen = true
end
-- Anzeige Positionskarte
if (DSZusatz.REGION["0"] and DN.NS.WertZeile and DN.EW.WertZeile and DSMB.anzeigen == true) then
DSMB.PK = {
title = "Positionskarte",
args = {
"Welt",
border = "none",
float = "inline",
width = "360",
maptype = "relief",
label = DSZusatz.NNAME,
label_size = "75%",
background = "#fff4d5",
lat = tostring( DN.NS.WertSplit[1] ),
long = tostring( DN.EW.WertSplit[1] ),
type = "building",
name = DSZusatz.NNAME,
region = DN["REGION-ISO"]["WertZeile"],
Breite = nil
}
}
DSMB.TMP.DL = 1
DSMB.Karte[1] = {
G = "Welt",
Bmax = 360,
Hmax = 1000,
Amax = 48000
}
if DSZusatz.REGION["0"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["0"]["map"] or DSMB.Karte[1]["G"] end
if DSZusatz.REGION["1"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["1"]["map"] or DSMB.Karte[1]["G"] end
if DSZusatz.REGION["2"] then DSMB.Karte[1]["G"] = DSZusatz.REGION["2"]["map"] or DSMB.Karte[1]["G"] end
if DN.POSKARTE.WertSplit[1] then
if mw.getCurrentFrame():callParserFunction( "#ifexist", { "Vorlage:Positionskarte " .. DN.POSKARTE.WertSplit[1], "1", "0" } ) == "1" then
DSMB.Karte[1]["G"] = DN.POSKARTE.WertSplit[1]
end
end
DSMB.Karte.obige = frame:expandTemplate{ title = "Obige Karte", args = { DSMB.Karte[1]["G"] } }
-- Sonderfestlegung
if DSMB.Karte.obige == "USA" then DSMB.Karte.obige = "USA 48" end
if DSZusatz.REGION["1"] then
if DSZusatz.REGION["0"]["acronym"] == "RU" then
if (DSZusatz.REGION["1"]["continent"] == "Europa" or DSZusatz.REGION["1"]["continent"] == "Eurasien") then DSMB.Karte.obige = "Russland Europäischer Teil" end
end
end
-- Anpassung 'obige Karte'
for OPKk, OPKv in pairs( DSZusatz.OPK ) do
if OPKv[1] == DSMB.Karte[1]["G"] then DSMB.Karte.obige = OPKv[2] end
DSMB.Karte.obige = DSMB.Karte.obige or "Welt"
end
if (DSMB.Karte.obige ~= "Welt" and DSMB.Karte.obige ~= "") then
DSMB.Karte[2] = {
G = DSMB.Karte.obige
}
DSMB.Karte[1]["Amax"] = DSMB.Karte[1]["Amax"] * 1.25
DSMB.TMP.DL = 2
end
for DL = 1, DSMB.TMP.DL, 1 do
DSMB.Karte[DL]["img"] = frame:expandTemplate{ title = "Positionskarte " .. DSMB.Karte[DL]["G"], args = { "image", "relief" } }
DSMB.Karte[DL]["Borg"] = mw.title.new( DSMB.Karte[DL]["img"], 6 ).file.width
DSMB.Karte[DL]["Horg"] = mw.title.new( DSMB.Karte[DL]["img"], 6 ).file.height
DSMB.Karte[DL]["Aorg"] = DSMB.Karte[DL]["Borg"] * DSMB.Karte[DL]["Horg"]
DSMB.Karte[DL]["SV"] = DSMB.Karte[DL]["Borg"] / DSMB.Karte[DL]["Horg"]
DSMB.Karte[DL]["Bgr"] = math.sqrt( DSMB.Karte[DL]["Amax"] * DSMB.Karte[DL]["SV"] )
DSMB.Karte[DL]["Hgr"] = DSMB.Karte[DL]["Bgr"] / DSMB.Karte[DL]["SV"]
if DSMB.Karte[DL]["Bgr"] > DSMB.Karte[DL]["Bmax"] then
DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["Bmax"]
DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["B"] / DSMB.Karte[DL]["SV"]
elseif DSMB.Karte[DL]["Hgr"] > DSMB.Karte[DL]["Hmax"] then
DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["Hmax"]
DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["H"] * DSMB.Karte[DL]["SV"]
else
DSMB.Karte[DL]["B"] = DSMB.Karte[DL]["Bgr"]
DSMB.Karte[DL]["H"] = DSMB.Karte[DL]["Hgr"]
end
DSMB.Karte[DL]["A"] = DSMB.Karte[DL]["B"] * DSMB.Karte[DL]["H"]
if (DL == 1 and DSMB.TMP.DL == 2) then
DSMB.Karte[2]["Bmax"] = DSMB.Karte[1]["B"]
DSMB.Karte[2]["Hmax"] = DSMB.Karte[1]["H"]
DSMB.Karte[2]["Amax"] = DSMB.Karte[1]["A"] / 5
end
if DL == 2 then
DSMB.PK.args["Karte in einer Ecke"] = DSMB.Karte[2]["G"]
DSMB.PK.args.Breite = tostring( math.floor( DSMB.Karte[2]["B"] ) )
end
end
DSMB.PK.args[1] = DSMB.Karte[1]["G"]
DSMB.PK.args.width = tostring( math.floor( DSMB.Karte[1]["B"] ) )
DSMB.VKarte = frame:expandTemplate{ title = DSMB.PK.title, args = DSMB.PK.args } or ""
DN.POSKARTE.WertZeile = DSMB.VKarte
else
DN.POSKARTE.WertZeile = ""
end
if DN.POSKARTE.WertZeile == "" then DN.POSKARTE.WertZeile = nil end
return DN
end
-- Anzeige Koordinaten 'KoordKarte'
p.DSIB.KoordKarte = function ( DN, DSZusatz, Kategorien, frame )
local DSMB = { }
-- Variable für die Wiki-Vorlage
DSMB.Artikel = false -- sollen Koordinaten im Artikel oben angezeigt werden
DSMB.Anzeige = true -- sollen Koordinaten in der Infobox angezeigt werden
DSMB.Rahmen = true -- soll die Anzeige mit einem Rahmen versehen werden
DSMB.brF = false -- Absatz vor DSMB.Fehler
DSMB.Fehler = { -- Speicher fuer Fehlermeldung
GZNS = "Gradzahl-Fehler:<br />\'\'[[Vorlage:Coordinate#NS und EW|NS]]\'\': keine Zahl",
GZEW = "Gradzahl-Fehler:<br />\'\'[[Vorlage:Coordinate#NS und EW|EW]]\'\': keine Zahl",
GBNS = "Gültigkeitsbereich Breitengrad: „" .. tostring( DN.NS.WertSplit[1] ) .. "“",
GBEW = "Gültigkeitsbereich Längengrad: „" .. tostring( DN.EW.WertSplit[1] ) .. "“"
}
DSMB.NS = DN.NS.WertSplit[1] or ""
DSMB.EW = DN.EW.WertSplit[1] or ""
DSMB.KOA = {
title = "Coordinate",
args = {
NS = tostring( DSMB.NS ),
EW = tostring( DSMB.EW ),
type = "building",
region = DN["REGION-ISO"]["WertZeile"],
name = DSZusatz.NNAME,
dim = "250"
}
}
-- Zuweisung fuer Rahmen
if ((DN.NS.WertZeile and DN.EW.WertZeile) or (DN.NS.AnzSplit == 0 and DN.EW.AnzSplit == 0)) then DSMB.Rahmen = false end
if not DSZusatz.REGION["0"] then
DSMB.KOA.args["type"] = "building"
if (DN.NS.WertSplit[1] and DN.EW.WertSplit[1]) then
DSMB.Rahmen = true
DSMB.brF = true
end
end
if ((DN.NS.WertZeile and type( DN.NS.WertSplit[1] ) == "number" and DN.EW.WertSplit[1] == nil) or (DN.EW.WertZeile and type( DN.EW.WertSplit[1] ) == "number" and DN.NS.WertSplit[1] == nil)) then
DSMB.Rahmen = nil
end
-- Zuweisung zur Anzeige
if DN.SONDER.WertZeile == "Nebenbox" then
DSMB.Artikel = false
elseif DN.SONDER.WertZeile == "Weiterleitung" then
DSMB.Artikel = true
elseif DSZusatz.NSP == 0 then
DSMB.Artikel = true
end
-- Zuweisung zur Wiki-Vorlage
if DSMB.Artikel == true then
DSMB.KOA.args.article = "/"
if ((DN.NS.WertZeile and DN.EW.WertZeile) or (DN.NS.AnzSplit == 0 and DN.EW.AnzSplit == 0) or (DN.NS.WertZeile and DN.EW.AnzSplit == 0) or (DN.NS.AnzSplit == 0 and DN.EW.WertZeile)) then
DSMB.Anzeige = false
end
if (DSZusatz.REGION["0"] == nil and DN.NS.WertZeile and DN.EW.WertZeile) then DSMB.Anzeige = true end
else
DSMB.KOA.args.text = "/"
end
if DSMB.Anzeige == false then
DN.KoordKarte.BauTyp = "Feld"
DN.KoordKarte.AnzLabel = ""
end
-- Generierung Vorlage:Coordinate und Fehlertexte
DN.KoordKarte.WertZeile = frame:expandTemplate{ title = DSMB.KOA.title, args = DSMB.KOA.args }
if (type( DN.NS.WertSplit[1] ) ~= "number" or type( DN.NS.WertZeile ) == "string") then DSMB.Fehler.GBNS = nil end
if (type( DN.EW.WertSplit[1] ) ~= "number" or type( DN.EW.WertZeile ) == "string") then DSMB.Fehler.GBEW = nil end
if DN.NS.AnzSplit > 0 then DSMB.Fehler.GZEW = nil end
if DN.EW.AnzSplit > 0 then DSMB.Fehler.GZNS = nil end
if type( DN.NS.WertSplit[1] ) ~= "string" then DSMB.Fehler.GZNS = nil end
if type( DN.EW.WertSplit[1] ) ~= "string" then DSMB.Fehler.GZEW = nil end
if (DSMB.Fehler.GZNS and DSMB.Fehler.GZEW) then
DSMB.Fehler.GZNS = nil
DSMB.Fehler.GZEW = nil
DSMB.brF = true
end
for Gk, Gv in pairs( DSMB.Fehler ) do
if DSMB.brF == true then
DN.KoordKarte.WertZeile = DN.KoordKarte.WertZeile .. "<br />"
else
DSMB.brF = true
end
if type( Gv ) == "string" then DN.KoordKarte.WertZeile = DN.KoordKarte.WertZeile .. Gv end
end
if DSMB.Rahmen == true then DN.KoordKarte.WertZeile = DSZusatz.Aufbereitung.Fehler( DN.KoordKarte.WertZeile ) end
return DN
end
-- Region-ISO in Feld
p.DSFI = function ( DatenWL, frame )
local DSFz = ""
local DSFD = { }
DSFD["0"] = { }
DSFD["0"]["level"] = 0
DSFD["0"]["continent"] = REG( "O", "continent", DatenWL, frame )
DSFD["0"]["acronym"] = REG( "O", "acronym", DatenWL, frame )
DSFD["0"]["admtype"] = REG( "O", "admtype", DatenWL, frame )
DSFD["0"]["admname"] = REG( "O", "admname", DatenWL, frame )
DSFD["0"]["name"] = REG( "O", "name", DatenWL, frame )
DSFD["0"]["lemma"] = REG( "O", "lemma", DatenWL, frame )
DSFD["0"]["map"] = REG( "O", "map", DatenWL, frame )
DSFD["0"]["flag"] = REG( "O", "flag", DatenWL, frame )
DSFD["0"]["Lin"] = "in " .. tostring( DSFD["0"]["name"] )
DSFz = REG( "O", "in", DatenWL, frame )
if DSFz ~= "" then DSFD["0"]["Lin"] = DSFz end
DSFD["1"] = { }
DSFD["1"]["level"] = 1
DSFD["1"]["continent"] = REG( "I", "continent", DatenWL, frame )
DSFD["1"]["acronym"] = REG( "I", "acronym", DatenWL, frame )
DSFD["1"]["admtype"] = REG( "I", "admtype", DatenWL, frame )
DSFD["1"]["admname"] = REG( "I", "admname", DatenWL, frame )
DSFD["1"]["name"] = REG( "I", "name", DatenWL, frame )
DSFD["1"]["lemma"] = REG( "I", "lemma", DatenWL, frame )
DSFD["1"]["map"] = REG( "I", "map", DatenWL, frame )
DSFD["1"]["flag"] = REG( "I", "flag", DatenWL, frame )
DSFD["1"]["Lin"] = "in " .. tostring( DSFD["1"]["name"] )
DSFz = REG( "I", "in", DatenWL, frame )
if DSFz ~= "" then DSFD["1"]["Lin"] = DSFz end
DSFD["2"] = { }
DSFD["2"]["continent"] = REG( "II", "continent", DatenWL, frame )
DSFD["2"]["level"] = REG( "II", "level", DatenWL, frame )
DSFD["2"]["acronym"] = REG( "II", "acronym", DatenWL, frame )
DSFD["2"]["admtype"] = REG( "II", "admtype", DatenWL, frame )
DSFD["2"]["admname"] = REG( "II", "admname", DatenWL, frame )
DSFD["2"]["name"] = REG( "II", "name", DatenWL, frame )
DSFD["2"]["lemma"] = REG( "II", "lemma", DatenWL, frame )
DSFD["2"]["map"] = REG( "II", "map", DatenWL, frame )
DSFD["2"]["flag"] = REG( "II", "flag", DatenWL, frame )
DSFD["2"]["Lin"] = "in " .. tostring( DSFD["2"]["name"] )
DSFz = REG( "II", "in", DatenWL, frame )
if DSFz ~= "" then DSFD["2"]["Lin"] = DSFz end
if DSFD["0"]["acronym"] == "NL" then
if (DSFD["2"]["acronym"] == "AW" or DSFD["2"]["acronym"] == "CW" or DSFD["2"]["acronym"] == "SX") then
DSFD["0"]["Lin"] = "im Königreich der Niederlande"
else
DSFD["0"]["Lin"] = "in den Niederlanden"
end
end
if DSFD["2"]["level"] == "2" then
if DSFD["0"]["acronym"] == DSFD["1"]["acronym"] then
DSFD["1"] = DSFD["2"]
DSFD["1"]["level"] = 2
DSFD["2"] = nil
else
DSFD["2"]["level"] = 2
end
elseif DSFD["2"]["level"] == "1" then
DSFD["1"] = DSFD["2"]
DSFD["1"]["level"] = 1
DSFD["2"] = nil
elseif DSFD["2"]["level"] == "0" then
DSFD["0"] = DSFD["2"]
DSFD["0"]["level"] = 0
DSFD["1"] = nil
DSFD["2"] = nil
else
DSFD["0"] = nil
DSFD["1"] = nil
DSFD["2"] = nil
end
return DSFD
end
-- Regionen fuer Geo-Regionen auswaehlen
p.GeoVERW = function ( Art, Ort, KFSv, REGION, DCSTADT )
local REGIO = REGION or { }
local DSTADT = DCSTADT or ""
local KFS = KFSv or "Stuttgart"
if REGIO[KFS] == nil then REGIO[KFS] = { } end
local VXW = {
CSTADT = {
tostring( DSTADT ),
"nicht " .. tostring( DSTADT ),
Gastronomiebetrieb = "(" .. tostring( KFS ) .. ")"
},
REG = {
tostring( REGIO[KFS]["Lin"] ),
"nicht " .. tostring( REGIO[KFS]["Lin"] ),
Gastronomiebetrieb = "(" .. tostring( REGIO[KFS]["name"] ) .. ")"
}
}
local LOC = VXW["CSTADT"][1]
if (Ort ~= nil and Ort ~= "") then
LOC = VXW[Ort][1]
if (Art ~= nil and Art ~= "") then
if (VXW[Ort][Art] ~= nil and VXW[Ort][Art] ~= "") then
LOC = VXW[Ort][Art]
end
end
end
return LOC
end
-- Datenermittlung bei Weiterleitung
p.DatenWeiterleitung = function ( Daten, frame )
-- Ziel definieren
local Ziel = {
Name = mw.getCurrentFrame():getParent().args.ZIEL or frame.args.ZIEL
}
Ziel.Splitten1 = { }
Ziel.Splitten2 = { }
Ziel.NSP = 0
if Ziel.Name then Ziel.Splitten1 = mw.text.split( Ziel.Name, "#" ) end
if Ziel.Splitten1[1] then Ziel.Splitten2 = mw.text.split( Ziel.Splitten1[1], ":" ) end
if Ziel.Splitten2[2] then Ziel.NSP = Ziel.Splitten2[1] end
Ziel.Seite = Ziel.Splitten2[2] or Ziel.Splitten2[1]
Ziel.Abschnitt = Ziel.Splitten1[2]
if Ziel.Seite == "" then Ziel.Seite = nil end
if Ziel.Abschnitt == "" then Ziel.Abschnitt = nil end
if Ziel.Seite then Ziel.Inhalt = mw.title.new( Ziel.Seite, Ziel.NSP ):getContent() end
Ziel.Splitten1 = nil
Ziel.Splitten2 = nil
-- Infobox extrahieren
if Ziel.Inhalt then
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "Infobox Sendeanlage", "XXXTA" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " SONDER", " XXXTE" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|SONDER", "| XXXTE" )
Ziel.Splitten = mw.text.split( Ziel.Inhalt, "XXXTA" )
Ziel.Inhalt = Ziel.Splitten[2]
end
if Ziel.Inhalt then
Ziel.Splitten = mw.text.split( Ziel.Inhalt, "XXXTE" )
if Ziel.Splitten[2] then
Ziel.Inhalt = Ziel.Splitten[1]
else
Ziel.Inhalt = nil
end
end
-- Parameter bestimmen
if Ziel.Inhalt then
for PEk, PEv in pairs( Daten ) do
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " " .. PEv.Name, " XXXPEA" .. PEv.Name )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|" .. PEv.Name, "| XXXPEA" .. PEv.Name )
end
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " REGION", " XXXPEAREGION" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|REGION", "| XXXPEAREGION" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_TYP", " XXXPEACAT_TYP" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_TYP", "| XXXPEACAT_TYP" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_NAME", " XXXPEACAT_NAME" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_NAME", "| XXXPEACAT_NAME" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, " CAT_STADT", " XXXPEACAT_STADT" )
Ziel.Inhalt = string.gsub( Ziel.Inhalt, "|CAT_STADT", "| XXXPEACAT_STADT" )
Ziel.Splitten = nil
Ziel.Splitten = string.find( Ziel.Inhalt, "XXXPEA" )
if not Ziel.Splitten then Ziel.Inhalt = nil end
end
-- Datensaetze extrahieren
if Ziel.Inhalt then
Ziel.Splitten = mw.text.split( Ziel.Inhalt, "XXXPEA" )
Ziel.vorTabelle = { }
for DSEk, DSEv in pairs( Ziel.Splitten ) do
if DSEk > 1 then
Ziel.ZTL = string.len( DSEv )
Ziel.ZTZ1 = string.sub( DSEv, Ziel.ZTL )
Ziel.ZTZ2 = string.sub( DSEv, Ziel.ZTL - 1 )
if Ziel.ZTZ2 == "| " then
table.insert( Ziel.vorTabelle, string.sub( DSEv, 0, Ziel.ZTL - 3 ) )
elseif Ziel.ZTZ1 == "|" then
table.insert( Ziel.vorTabelle, string.sub( DSEv, 0, Ziel.ZTL - 2 ) )
end
end
end
end
-- Datensaetze aufteilen
if Ziel.vorTabelle then
Ziel.ZwischenTabelle, Ziel.Splitten = { }, { }
for DSF1k, DSF1v in pairs( Ziel.vorTabelle ) do
Ziel.ZwischenTabelle[DSF1k] = { }
Ziel.Splitten = mw.text.split( DSF1v, "=" )
for DSF2k, DSF2v in pairs( Ziel.Splitten ) do
if DSF2k < 3 then
Ziel.ZwischenTabelle[DSF1k][DSF2k] = DSF2v
elseif DSF2k == 2 then
Ziel.ZwischenTabelle[DSF1k][2] = Ziel.ZwischenTabelle[DSF1k][2] .. DSF2v
end
end
Ziel.ZwischenTabelle[DSF1k][1] = mw.text.trim( Ziel.ZwischenTabelle[DSF1k][1] )
Ziel.ZwischenTabelle[DSF1k][2] = mw.text.trim( Ziel.ZwischenTabelle[DSF1k][2] )
if Ziel.ZwischenTabelle[DSF1k][1] == "" then Ziel.ZwischenTabelle[DSF1k][1] = "blind" end
if Ziel.ZwischenTabelle[DSF1k][2] == "" then Ziel.ZwischenTabelle[DSF1k][2] = nil end
end
end
-- Tabelle erzeugen
Ziel.Tabelle = { false }
if Ziel.ZwischenTabelle then
Ziel.Tabelle[1] = true
for TABk, TABv in pairs( Ziel.ZwischenTabelle ) do
Ziel.Tabelle[TABv[1]] = TABv[2]
end
Ziel.Tabelle.ZIEL = Ziel.Name
Ziel.Tabelle.ZIELNSP = Ziel.NSP
Ziel.Tabelle.ZIELSeite = Ziel.Seite
Ziel.Tabelle.ZIELAbschnitt = Ziel.Abschnitt
end
return Ziel.Tabelle
end
return p