Die Dokumentation für dieses Modul kann unter Modul:Vorlage:AudioVideo/Doku erstellt werden

--[=[ 2014-07-13
Unterstützung für {{AudioVideo}}
]=]
 
 
-- Global
local Selbst = "Vorlage:AudioVideo"
local Zitation
local KategorieBeginn  =  "Kategorie:Wikipedia:Vorlagenfehler/" .. Selbst
local Kategorien       =
     { Intern          = { s = "/Interner Fehler" },
       Parameter       = { s = "/Parameterfehler" }
     }
local Fehler = false
 
local Parameter = [==[
|titel
|Datum
|Ausstrahlungsdatum
|Ausstrahlung
|Sender
|Online
|Titel
|Reihe
|Format
|Zeit
|Länge
|Buch
|Autor
]==]
 
local function fault( a )
    -- Formatiere Fehler mit class=error
    -- Parameter:
    --     a  -- string mit Text
    return string.format( "<span class=\"error\">%s</span>", a )
end -- fault()
 
 
 
local function fehler( art, anzeige )
    -- Ein Fehler ist aufgetreten
    -- Parameter:
    --     art      -- string mit Schlüsselwort zum Typ
    --     anzeige  -- string mit Einzelheiten
    local t
    if not Fehler then
    	Fehler = { Intern    = { s = "Interner Fehler",
                                 k = "Intern" },
                   Modul     = { s = "Modul-Seite fehlt",
                                 k = "Intern" },
                   Vorlage   = { s = "Vorlagen-Seite fehlt",
                                 k = "Intern" },
                   Konflikt  = { s = "Parameterkonflikt",
                                 k = "Parameter" },
                   Parameter = { s = "Parameterfehler",
                                 k = "Parameter" },
                   Pflicht   = { s = "Pflichtparameter fehlt",
                                 k = "Parameter" },
                   Wert      = { s = "Ungültig",
                                 k = "Parameter" },
                   Doppelt   = { s = "Mehrfache Angabe von Parametern",
                                 k = "Parameter" }
                 }
    end
    t = Fehler[ art ]
    if t then
        if t.e then
            t.e  =  string.format( "%s; %s", t.e, anzeige )
        elseif anzeige then
            t.e  =  anzeige
        else
            t.e  =  ""
        end
        if t.k then
            local wk  =  Kategorien[ t.k ]
            if wk then
                wk.e  =  true
            else
                Fehler.Intern.e      =  string.format( "Wartungskat %s", wk )
                Kategorien.Intern.e  =  true
            end
        end
    else
        Fehler.Intern.e      =  string.format( "fehler(%s) %s", art, anzeige )
        Kategorien.Intern.e  =  true
    end
end -- fehler()
 
 
 
local function fehlerliste()
    -- Auflistung aller Fehlermeldungen
    -- Rückgabewert: string mit formatiertem Ergebnis
    local r = ""
    local sep = ""
    if Fehler then
        for k, v in pairs( Fehler ) do
             if v.e then
                r = string.format( "%s%s*** %s: %s", r, sep, v.s or "", v.e)
                sep = " "
            end
        end -- for k, v
        r = "<br />" .. fault( r )
    end
    return r
end -- fehlerliste()
 
 
 
local function fire( art )
    -- Melde Kategorie an
    -- Parameter:
    --     art  -- string mit Schlagwort zum Typ
    local t = Kategorien[ art ]
    if t then
        t.e  =  true
    else
        fehler( "Intern",  "Kategorie:" .. art )
    end
end -- fire()
 
 
 
local function firelist()
    -- Auflistung aller gemeldeten Kategorien
    -- Returns: string mit allen Kategorien
    local r  =  ""
    local s
    for k, v in pairs( Kategorien ) do
        if v.e then
            if v.x then
                s  =  "Kategorie:Wikipedia:"
            else
                s  =  KategorieBeginn
            end
            r = string.format( "%s[[%s%s]]", r, s, v.s )
        end
    end -- for k, v
    return r
end -- firelist()
 
 
 
local Autor = function ( args )
    local r = args.Buch or args.Autor
    if r then
        if  args.Buch and args.Autor then
            fehler( "Doppel", "'Buch' und 'Autor'" )
        end
    end
    return r
end -- Autor()
 
 local Datum = function ( args, name )
    local lucky, m = pcall( require, "Modul:Vorlage:FormatDate" )
    local r = args[name]
    -- ToDo Fehlerausgabe wenn das Datum nicht im ISO-Format angegeben wurde
    if type( m ) == "table" then
        -- FormatDate = m["Vorlage:FormatDate"]()
    	if r then
        	--r = FormatDate( r )
        elseif name == "zugriff" then
        	fehler( "Pflicht" , "'zugriff'" )
    	end
    else
        fehler( "Modul", m )
    end
    return r
end -- Datum()
 
 

local Kommentar = function ( args )
    local r = ""
    local sep = ""
    if args.Format then
    	r = r .. sep .. args.Format
    	sep = ", "
	end
    if args["Länge"] then
    	r = r .. sep .. args["Länge"]
    	sep = ", "
	end
    if args.Kommentar then
    	r = r .. sep .. args.Kommentar
    	sep = ", "
	end
	
    return r
end -- Kommentar()

local Online = function ( args )
    local r = args.Online
    if r then
        -- Wenn nur eine URL angebeben wird:
        --  zunächst einfach nur prüfen ob ein Leerzeichen enthalten ist
        --if not mw.ustring.find(r,"%s") then
        --    r = "[" .. r .. " online]"
        --end
        -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
        -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
        -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
        -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
        -- Alternative Vorschläge:
        -- 1. Wenn nur URL dann in Modul:Zitation den Titel verlinken
        -- 2. Wenn für {{LIT}} immer in der nachgestellten Form,
        --    dann die aussagekräftiger Domain als Linktitel
        --    statt des wertlosen "online" (Jedes Link ist online).
        --    Also "books.google.de" oder "springerlink.com" generieren.
    end
    return r
end -- Online()

 
local format = function ( args )
    -- Analysiere Argumente und bilde formatierte Zitation
    -- Parameter:
    --     args  -- table mit Vorlagenparametern
    -- Rückgabewert: string mit formatierter Zitation
    local r
    local z = { }
    local pars, schrott = Zitation.filter( args, Parameter )
    if schrott then
        fehler( "Parameter", schrott )
    end
    z.Autor        = Autor( pars )
    z.Titel        = pars.Titel
    z.Reihe        = pars.Reihe
    --z.Titel = Land(pars) .. pars["V-Nr"] .. ": " .. pars.Titel
 
    z.Sender             = pars.Sender
    z.Ausstrahlungsdatum = Datum( pars, "Ausstrahlungsdatum" )
    z.Datum        		 = Datum( pars, "Datum" )
    z.Zeit        		 = pars.Zeit
 
    z.Weblink          = Online (pars)
    if pars.Online then
    	z.Abruf        = Datum( pars, "Zugriff" )
    end

    z.Kommentar    = Kommentar (pars)	

    z.COinS        = false
    z._Selbst      = "AudioVideo"

    r, schrott = Zitation.format( z )
    if schrott then
        r = r .. schrott
        --fehler( "Wert", schrott )
    end
    return r
end -- format()
 
 
 
local function f( a )
    -- Hauptfunktion zur Steuerung des Gesamtablaufs
    -- Rückgabewert: string mit formatiertem Gesamtergebnis
    local lucky, r = pcall( require, "Modul:Zitation" )
    if type( r ) == "table" then
        Zitation = r.Zitation()
        r = format( a )
    else
        fehler( "Modul", r )
    end
    r = r .. fehlerliste()
    return  r
end -- f()
 
 
 
-- Export
local p = {}
 
function p.test( a )
    local lucky, r = pcall( f, a )
    return r
end
 
function p.f( frame )
    local lucky, r = pcall( f, frame:getParent().args )
    return r
end
 
return p