Inhaltsverzeichnis
Programmierhandbuch
Inhaltsverzeichnis
Programmierhandbuch
Module |
|
##################################################################################### # # Dateiname : Dateiname # Import : Importierte Quelldateien, die allen Modulen zur Verfgung stehen # Beschreibung : Klassifizierung der Module # # Prozeduren : Namen der Module, die in der Datei definiert sind # # globale Variablen : Innerhalb der Datei definierte globale Variable # # Programmierer : # Žnderungen : Datum Beschreibung # - - # #####################################################################################
#----------------------------------------------------------------------------- # Modulname : Modulname # Beschreibung : Modulbeschreibung # # Parameter : Argumente dieses Moduls # in Inputparameter # out Referenzparameter # Name Name des Parameters # Datentyp Datentyp # Beschreibung Beschreibung # # globaler Zugriff : Variablenname Lesezugriff Schreibzugriff # Name der globalen Variablen, auf die lesend # und/oder schreibend zugegriffen wird. # # Rckgabewert und # Fehlerbehandlung : Beschreibung des Rckgabewertes und der Ausnahmebehandlung # # Programmierer : # Žnderungen : Datum Beschreibung # - - # #-----------------------------------------------------------------------------
##############################################################################
#
# Dateiname : header.tcl
# Import : -
# Beschreibung : Module zum Laden und Abspeichern der Indexstrukturen von
# und auf die Festplatte.
# Deklariert s„mtliche globalen Variablen
#
# Prozeduren : Gruppe I
# save_index_structures {directory lists arrays}
# load {directory lists arrays}
#
# globale Variablen : Name Datentyp Beschreibung
# semester assoziatives Array Angabe, ob die Veranstaltung im Sommersemester oder im Wintersemester
# stundenVorlesung assoziatives Array Zeitbedarf der Veranstaltungen w„hrend des Semesters in Zeitstunden
# stundenPruefung assoziatives Array Zeitbedarf fr Prfungsvorbereitungen und Prfungen
# credits assoziatives Array Arbeitsaufwand eines Studierenden, der mit der jeweiligen Veranstaltung verbunden ist
# sws assoziatives Array Anzahl der Semesterwochenstunden dieser Vorlesung
# kategorie assoziatives Array Kategorie der Veranstaltung
# unterKategorie assoziatives Array Unterkategorie der Veranstaltung
# assessment assoziatives Array zu erbringender Nachweis am Ende des Semesters
# titel assoziatives Array Name der Veranstaltung
# beschreibung assoziatives Array Beschreibung der Veranstaltung
# kommentar assoziatives Array Kommentar der Veranstaltung
# referenz assoziatives Array Literaturangaben
# partnerveranstaltung assoziatives Array Veranstaltungsnummer verwandert Veranstaltungen
# language assoziatives Array Sprache der Beschreibung
# lang assoziatives Array Sprache der Beschreibung
# pruefungsordnung assoziatives Array Angabe in welchen Prfungsordnungen diese Veranstaltung enthalten ist und im welchen Semester sie gehalten wird
# mitarbeiter assoziatives Array Titel, Vorname und Nachname des Mitarbeiters, der die Veranstaltung h„lt
#
# id List Veranstaltungsnummer
# hoererStati List Optionen, ob die Veranstaltung im Sommer- oder Wintersemester gelesen wird
#
# all_lists List Auflistung der Namen aller Indexstrukturen, die Listen sind
# all_arrays List Auflistung der Namen aller Indexstrukturen, die assoziatve Arrays sind
# all_indizes List Auflistung der Namen aller Indexstrukturen
#
# standard_request String Standardanfrage
# standard_request_list Liste Standardanfrage im Listenformat
#
##############################################################################
#-----------------------------------------------------------------------------
# Variablendeklaration
#-----------------------------------------------------------------------------
# Deklaration der Indexstrukturen
set semester() {}
set stundenVorlesung() {}
set stundenPruefung() {}
set credits() {}
set sws() {}
set kategorie() {}
set unterKategorie() {}
set assessment() {}
set titel() {}
set beschreibung() {}
set kommentar() {}
set referenz() {}
set partnerveranstaltung() {}
set language() {}
set lang() {}
set pruefungsordnung() {}
set mitarbeiter() {}
set id {}
set hoererStati { ss ws }
set all_lists { hoererStati id }
set all_arrays { semester stundenVorlesung stundenPruefung sws partnerveranstaltung referenz lang mitarbeiter pruefungsordnung kategorie assessment credits unterKategorie titel kommentar beschreibung }
set all_indizes { semester stundenVorlesung stundenPruefung sws partnerveranstaltung referenz lang mitarbeiter pruefungsordnung kategorie assessment credits unterKategorie titel kommentar beschreibung }
set standard_request "seite=0&language=DE&titel=alle&kategorie=alle&unterkategorie=alle&pruefungsordnung=alle&semester=alle&mitarbeiter=alle&assessment=alle&hoererstatus=[lindex $hoererStati 0]"
set standard_request_list { { seite 0 } { language DE } { titel alle } { kategorie alle } { unterkategorie alle } { pruefungsordnung alle } { semester alle } { mitarbeiter alle } { assessment alle } { hoererstatus ss } }
#-----------------------------------------------------------------------------
# Modulname : save_index_structures
# Beschreibung : Abspeichern der Indexstrukturen in das Verzeichnis
# der Festplatte.
# Die Elemente der Listen und sind die Namen
# von Variablen im Geltungsbereichs der aufrufenden Prozedur.
# Die Liste enth„lt die Variablennamen von Listen.
# Die Liste enth„lt die Variablennamen von assoziatives Arrays.
# Fr jede Variable wird eine Textdatei gleichen Namens
# angelegt (Pr„fix .txt), in die der Wert der Variablen ge-
# speichert und im Verzeichnis abgelegt wird.
# Wenn die Referenzvariable nicht existiert, wird entweder eine
# leere Liste bzw. eine leeres assoziatives Array gleichen Namens angelegt.
# Wenn das Verzeichnis nicht existiert, wird ein neues angelegt.
# Wenn die Referenzvariable nicht dem geforderten Typ entspricht, dann werden
# die Fehlermeldungen "Referenzvariable ist Liste und nicht Array" bzw.
# "Referenzvariable ist Array und nicht Liste" ausgegeben.
#
# Parameter : in | out Name Datentyp Beschreibung
# in directory string absoluter Pfad zu den Indexstrukturen
# in lists Liste Bestandteile der Liste sind Referenzparameter und zwar Listen
# in arrays Liste Bestandteile der Liste sind Referenzparameter und zwar assoziatives Arrays
#
#-----------------------------------------------------------------------------
proc save_index_structures {directory lists arrays} {
#Referenz auf Gltigkeitsbereich der aufrufenden Prozedur setzen
foreach element $lists {
upvar $element $element
if {[string compare [info exists $element] 0] == 0} {
set $element {}
}
}
#Referenz auf Gltigkeitsbereich der aufrufenden Prozedur setzen
foreach element $arrays {
upvar $element $element
if {[string compare [info exists $element] 0] == 0} {
set ${element}() {}
}
}
#wenn Verzeichnis nicht existiert, lege neues an
if {[string compare [file isdirectory $directory] 0] == 0} {
file mkdir $directory
}
foreach element $lists {
# wenn Liste ein Array, dann breche ab
if {[array exists $element] == 1} {
puts "Fehler: Variable $element ist Array und nicht Liste"
return
}
set tmpfile [open ${directory}${element}.txt w]
puts $tmpfile ${element}
puts $tmpfile [set $element]
close $tmpfile
}
foreach element $arrays {
set tmpfile [open ${directory}${element}.txt w]
# wenn Liste ein Array, dann breche ab
if {[array exists $element] == 0} {
puts "Fehler: Variable $element ist Liste und nicht Array"
return
}
foreach liste [array names $element] {
puts $tmpfile ${element}($liste)
puts $tmpfile [set ${element}($liste)]
}
close $tmpfile
}
}
#-----------------------------------------------------------------------------
# Modulname : load
# Beschreibung : Laden der Indexstrukturen auf dem Verzeichnis
# von der Festplatte.
# Die Elemente der Listen und sind die Namen
# von Variablen des Geltungsbereichs der aufrufenden Prozedur.
# Die Liste enth„lt die Variablennamen von Listen.
# Die Liste enth„lt die Variablennamen von assoziatives Arrays.
# Fr jede Variable wird eine Textdatei gleichen Namens
# angelegt (Pr„fix .txt), in die der Wert der Variablen ge-
# speichert und im Verzeichnis abgelegt wird.
# Wenn die Referenzvariable nicht existiert, wird entweder eine
# leere Liste bzw. eine leeres assoziatives Array gleichen Namens angelegt.
# Wenn das Verzeichnis nicht existiert, wird die Fehlermeldung
# "Verzeichnis xxx mit Indexstrukturen existiert nicht" ausgegeben.
# Wenn die Referenzvariable nicht dem geforderten Typ entspricht, dann werden
# die Fehlermeldungen "Referenzvariable ist Liste und nicht Array" bzw.
# "Referenzvariable ist Array und nicht Liste" ausgegeben.
# Wenn eine Indexstrukturdatei nicht existiert, wird eine leere Indexstruktur
# erzeugt.
#
# Parameter : in | out Name Datentyp Beschreibung
# in directory string absoluter Pfad zu dem Indexverzeichnis
# in/out lists Liste Bestandteile der Liste sind Referenzparameter und zwar Listen
# in/out arrays Liste Bestandteile der Liste sind Referenzparameter und zwar assoziatives Arrays
#
#-----------------------------------------------------------------------------
proc load {directory lists arrays} {
#Referenz auf Gltigkeitsbereich der aufrufenden Prozedur
foreach element $lists {
upvar $element $element
if {[string compare [info exists $element] 0] == 0} {
set $element {}
}
}
#Referenz auf Gltigkeitsbereich der aufrufenden Prozedur
foreach element $arrays {
upvar $element $element
if {[string compare [info exists $element] 0] == 0} {
set ${element}() {}
}
}
#wenn Verzeichnis nicht existiert, gibt Fehlercode zurck
if {[string compare [file isdirectory $directory] 0] == 0} {
puts "Fehler: Verzeichnis $directory mit Indexstrukturen existiert nicht"
return -1
}
#das Auslesen von Listen und Arrays ist identisch, da die eine Zeile immer
#den Variablennamen inkl. evtl. Key-Wert und die darauffolgende Zeile den
#Wert darstellt
foreach index [concat $lists $arrays] {
set myfile "${directory}${index}.txt"
if {[file exists $myfile] == 1} {
set tmpfile [open $myfile r]
while {[eof $tmpfile] != 1} {
set [gets $tmpfile] [gets $tmpfile]
}
close $tmpfile
}
}
}
##############################################################################
#
# Dateiname : part.tcl
# Import : -
# Beschreibung : L„dt die sprachabh„ngigen Bezeichnungen einer Veranstaltungs-
# seite aus der jeweiligen Konfigurationsdatei und ermittelt die
# zu einer bestimmten Veranstaltung geh”rigen Daten.
#
#
# Prozeduren : Gruppe I
# init_literale {language directory}
# init_values {language vid}
#
# globale Variablen : Name Datentyp
# Literale: lit_semester string Bezeichner auf der Vorlesungsseite
# val_semester string Wert auf der Vorlesungsseite
# lit_stundenVorlesung string
# val_stundenVorlesung string
# lit_stundenPruefung string
# val_stundenPruefung string
# lit_credit string
# val_credit string
# lit_sws string
# val_sws string
# lit_kategorie string
# val_kategorie string
# lit_unterkategorie string
# val_unterkategorie string
# lit_assessment string
# val_assessment string
# lit_titel string
# val_titel string
# lit_beschreibung string
# val_beschreibung string
# lit_kommentar string
# val_kommentar string
# lit_referenz string
# val_referenz string
# lit_partner string
# val_partner string
# lit_sprache string
# val_sprache string
# lit_pruefungsordnung string
# val_pruefungsordnung string
# lit_mitarbeiter string
# val_mitarbeiter string
#
# lit_fenstertitel string
# val_fenstertitel string
# lit_hoererstatus string
# val_hoererstatus string
# lit_alle string
# val_alle string
# lit_vorlesungen string
# val_vorlesungen string
# lit_arbeitsaufwand string
# val_arbeitsaufwand string
#
# all_literale list Liste aller Bezeichner
# all_values list Liste aller Werte
#
# tableDefault string HTML-Ersatzsymbol
#
##############################################################################
#-----------------------------------------------------------------------------
# Variablendeklaration
#-----------------------------------------------------------------------------
# neue Literale mssen in die all_*-Listen eingetragen werden
set all_literale { lit_hoererstatus lit_zurueck lit_fenstertitel lit_sws lit_semester lit_stundenVorlesung lit_stundenPruefung lit_credit lit_titel lit_beschreibung lit_kommentar lit_mitarbeiter lit_kategorie lit_unterkategorie lit_assessment lit_referenz lit_partner lit_pruefungsordnung lit_hoererstatus lit_alle lit_sprache lit_vorlesungen lit_arbeitsaufwand lit_titelanzeige}
set all_values { val_fenstertitel val_sws val_semester val_stundenVorlesung val_stundenPruefung val_credit val_titel val_beschreibung val_kommentar val_mitarbeiter val_kategorie val_unterkategorie val_assessment val_referenz val_partner val_pruefungsordnungen val_hoererstatus val_sprache }
set tableDefault " "
# Initialisierung aller globaler Variablen
foreach element $all_literale {
set lit_${element} &tableDefault
}
foreach element $all_values {
set val_${element} &tableDefault
}
#-----------------------------------------------------------------------------
# Prozeduren
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Modulname : init_literale
# Beschreibung : L„dt die sprachabh„ngigen Bezeichnungen einer Veranstaltungs-
# seite aus der jeweiligen Konfigurationsdatei .
# Liest die Datei "filename" zeilenweise aus. Aus dem ersten
# Element wird eine lokale Variable definiert, wobei
# der Rest der Zeile den Wert dieser Variablen darstellt. Jedes
# Element der Liste array ist ein Referenzparameter und wenn
# der Name einer lokalen Variablen dem des Referenzparameters entspricht
# wird die Referenz ver„ndert.
# Wenn die Referenzvariable nicht eistiert, wird die Variable
# mit dem Wert " " initialisiert.
# Wenn die Datei nicht eistiert, wird nichts getan.
#
#
# Bespiel: Zeile: myVariable value value value
# Variable: myVarable Wert: "value value value"
#
# Parameter : in | out Name Datentyp Beschreibung
# in filename string Dateiname inkl. Pfadangabe der
# Konfigurationsdatei aus der die
# Literale gelesen werden sollen
# Die Datei muá den Restriktionen
# entsprechen
# out array
#
#-----------------------------------------------------------------------------
proc init_literale {filename array} {
global tableDefault
foreach element $array {
upvar $element $element
set $element $tableDefault
}
if {[string compare [file eists $filename] 1] == 0} {
set tmpfile [open $filename r]
while {[eof $tmpfile] != 1} {
set row [gets $tmpfile]
set literal [lindex $row 0]
set value [lrange $row 1 end]
if {[string compare [string trim $value] ""] == 0} {
set value $tableDefault
}
set lit_${literal} $value
}
close $tmpfile
}
}
#-----------------------------------------------------------------------------
# Modulname : init_values
# Beschreibung : Ermittelt die zu einer bestimmten Veranstaltung geh”rigen Daten.
# Jedes Element der Liste array ist ein Referenzparameter und wenn
# der Name einer lokalen Variablen dem des Referenzparameters entspricht
# wird die Referenz ver„ndert.
# Wenn die Referenzvariable nicht existiert, wird eine
# Variable mit " " initialisiert.
# Wenn der Inhalt nicht ermittelt werden kann, wird die Referenz nicht ver„ndert.
#
# Parameter : in | out Name Datentyp Beschreibung
# in language string Sprache
# in vid string Veranstaltungsnummer
# out array Ergebnis
# in hoererstatus Daten des Sommer- oder Wintersemesters sollen ermittelt werden
# ben”tigt, um Links auf Partnerveranstaltungen zu erzeugen
# in script Skript
# in old_request alte Anfrage
#
#-----------------------------------------------------------------------------
proc init_values {language vid array hoererstatus script old_request} {
global tableDefault mitarbeiter
foreach element $array {
upvar $element $element
switch $element {
val_semester { set val_semester [rueck [getSemester $vid]] }
val_stundenVorlesung { set val_stundenVorlesung [rueck [getStundenVorlesung $vid]] }
val_stundenPruefung { set val_stundenPruefung [rueck [getStundenPruefung $vid]] }
val_credit { set val_credit [rueck [getCredit $vid]] }
val_sws { set val_sws [rueck [getSws $vid]] }
val_mitarbeiter { set val_mitarbeiter [rueck [join [getMitarbeiterPlusHREF $vid] " / "]] }
val_kategorie { set val_kategorie [rueck [getKategorie $language $vid]] }
val_unterkategorie { set val_unterkategorie [rueck [getUnterkategorie $language $vid]] }
val_titel { set val_titel [rueck [getTitel $language $vid]] }
val_assessment { set val_assessment [rueck [getAssessment $language $vid]] }
val_beschreibung { set val_beschreibung [rueck [getBeschreibung $language $vid]] }
val_kommentar { set val_kommentar [htmljezeile [rueck [getKommentar $language $vid]]] }
val_referenz { set val_referenz [htmljezeile [rueck [getReferenz $vid]]] }
val_partner { set val_partner [htmllinkjezeile [getPartner $vid] $script $old_request] }
val_pruefungsordnungen { set val_pruefungsordnungen [getPruefungsordnungen $vid $hoererstatus]}
}
}
}
##############################################################################
#
# Dateiname : parse_xml.tcl
# Import : -
# Beschreibung : Durch den Aufruf der Prozedur parse_veranstaltungXml
# wird der XMl-Parser aufgerufen, der das XML-Dokument
# liest und dabei die Indexstrukturen aufbaut.
# Die anderen Prozeduren sind Hilfsprozeduren und definieren
# wie die Indexstrukturen aufgebaut werden sollen.
#
# Prozeduren : startTag {tagName attrList}
# endTag {tagName}
# parser_push {data}
# parse_veranstaltungXml {xml_dokument} Zugriffsfunktion
#
# globale Variablen : -
#
##############################################################################
#-----------------------------------------------------------------------------
# Prozeduren
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Modulname : parse_veranstaltungXml
# Beschreibung : Liest das XML-Dokument xml_dokument und generiert die
# Indexstrukturen.
#
# Parameter : in | out Name Datentyp default Beschreibung
# in xml_dokument string
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# x x x
# x x x
#
# Rckgabewert und
# Fehlerbehandlung : 0 Das XML-Dokument wurde erfolgreich verarbeitet.
# -1 Wenn das Paket des TCLXML-Parsers nicht im
# Suchpfad des TCL-Interpreters enthalten ist, wird
# die Fehlermeldung "Cannot load xml 1.7 package"
# ausgeben und der Fehlercode zurckgegeben.
# -2 Wenn das XML-Dokument nicht existiert, wird dieser
# Fehlercode zurckegeben.
#
#-----------------------------------------------------------------------------
proc parse_veranstaltungXml {xml_dokument} {
#-----------------------------------------------------------------------------
# Importanweisungen
#-----------------------------------------------------------------------------
source toolbox.tcl
source header.tcl
#-----------------------------------------------------------------------------
# Variablendeklaration
#-----------------------------------------------------------------------------
# Stack, in dem die Daten von verschachtelten Tag-Strukturen
# zwischengespeichert werden.
variable ref_myStack {}
# aktuelle Veranstaltungsnummer
variable ref_currID ""
# aktuelle Sprache
variable ref_currLanguage ""
# aktuelle Kategorie
variable ref_currKategorie ""
# aktuelle ID eines Mitarbeiters
variable ref_currMitArbID ""
# aktuelle Homeadresse eines Mitarbeiters
variable ref_currMitArbURL ""
# aktueller Mitarbeitertitel
variable ref_currMitArbTitle ""
# aktuelle Partnerveranstaltung
variable ref_currPartnerID ""
#-----------------------------------------------------------------------------
# Prozeduren
#-----------------------------------------------------------------------------
#-------------------------------------------------------------------------
# Modulname : startTag
# Beschreibung : Prozedur, die aufgerufen wird, wenn im XML-Dokument ein
# Start-Tag gefunden worden ist.
#
# Parameter : in | out Name Datentyp Beschreibung
# in tagName string Name des Start-Tags
# in attrList list Attributliste des
# Start-Tags
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# currID + +
# currMitArbID - +
# currMitArbURL - +
# currMitArbTitle - +
# currLanguage + +
# currPartnerID - +
#
# Indexstruktur id - +
# I semester - +
# I lang - +
#
#-------------------------------------------------------------------------
proc startTag {tagName attrList} {
global id lang semester
upvar ref_currID currID ref_currMitArbTitle currMitArbTitle
upvar ref_currMitArbID currMitArbID ref_currMitArbURL currMitArbURL
upvar ref_currLanguage currLanguage ref_currPartnerID currPartnerID
switch $tagName {
veranstaltung { set currID [lindex $attrList [expr [lsearch $attrList id] + 1]]
lappend id $currID
lappend semester([lindex $attrList [expr [lsearch $attrList semester] + 1]]) $currID
}
mitarbeiter { set currMitArbID [lindex $attrList [expr [lsearch $attrList id] + 1]]
set currMitArbURL [lindex $attrList [expr [lsearch $attrList url] + 1]]
set currMitArbTitle [lindex $attrList [expr [lsearch $attrList title] + 1]]
}
definition { set currLanguage [lindex $attrList [expr [lsearch $attrList {xml:lang}] + 1]]
if {[lsearch $lang() $currLanguage] == -1 } {
lappend lang() $currLanguage
}
set lang($currID) [lappend lang($currID) $currLanguage]
}
partnerveranstaltung { set currPartnerID [lindex $attrList [expr [lsearch $attrList href] + 1]]
}
}
}
#-----------------------------------------------------------------------------
# Modulname : endTag
# Beschreibung : Prozedur, die aufgerufen wird, wenn im XML-Dokument ein
# Ende-Tag gefunden worden ist.
#
# Parameter : in | out Name Datentyp Beschreibung
# in tagName string Name des Ende-Tags
# in currID
# in currMitArbID
# in currMitArbURL
# in currMitArbTitle
# in currLanguage
# in currPartnerID
# in currKategorie
# in|out myStack
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# I titel - +
# I beschreibung - +
# I kommentar - +
# I kategorie - +
# I assessment - +
# I referenz - +
# I unterKategorie - +
# I partnerveranstaltung - +
# I pruefungsordnung - +
# I stundenVorlesung - +
# I stundenPruefung - +
# I credits - +
# I sws - +
# I mitarbeiter - +
#
#-----------------------------------------------------------------------------
proc endTag {tagName} {
global titel beschreibung kommentar kategorie assessment referenz
global unterKategorie partnerveranstaltung pruefungsordnung
global stundenVorlesung stundenPruefung credits sws mitarbeiter
upvar ref_currID currID ref_currMitArbTitle currMitArbTitle
upvar ref_currMitArbID currMitArbID ref_currMitArbURL currMitArbURL
upvar ref_currLanguage currLanguage ref_currPartnerID currPartnerID
upvar ref_currKategorie currKategorie ref_myStack myStack
switch $tagName {
veranstaltungsverzeichnis -
veranstaltung -
definition { pull myStack
pull myStack }
stundenVorlesung -
stundenPruefung -
credits -
sws { lappend ${tagName}([pull myStack]) $currID }
mitarbeiter { set currMitArbName [pull myStack]
set command ""
append command mitarbeiter ( $currMitArbName " " ( $currMitArbID ) )
#existiert Index fr den Mitarbeiter schon
if {[info exists $command] == 1} {
#wenn ja, erweitere Liste um aktuelle VID
set mitarbeiterVIDs [lindex [set $command] 4]
lappend mitarbeiterVIDs $currID
} else {
#wenn nein, initialisiere Liste
set mitarbeiterVIDs [list $currID]
}
set $command [list $currMitArbID $currMitArbName $currMitArbTitle $currMitArbURL $mitarbeiterVIDs] }
titel -
beschreibung -
kommentar { lappend ${tagName}(${currLanguage}_${currID}) [pull myStack] }
assessment { lappend ${tagName}(${currLanguage}_[pull myStack]) $currID }
kategorie { set data [pull myStack]
set currKategorie $data
# um sp„ter unterkategorien den Kategorien zuzuordnen
lappend ${tagName}(${currLanguage}_$data) $currID }
unterKategorie { lappend ${tagName}(${currLanguage}_${currKategorie}_[pull myStack]) $currID }
referenz { lappend ${tagName}($currID) [pull myStack] }
partnerveranstaltung { lappend ${tagName}($currID) [list $currPartnerID [pull myStack]] }
pruefungsordnung { pull myStack
set ws [pull myStack]
pull myStack
set ss [pull myStack]
set oid [pull myStack]
lappend pruefungsordnung(${oid}_$currID) $ss $ws
if {[lsearch $pruefungsordnung() $oid] == -1 } {
lappend pruefungsordnung() $oid
}
}
}
}
#-------------------------------------------------------------------------
# Modulname : parser_push
# Beschreibung : Prozedur, die aufgerufen wird, wenn im XML-Dokument eine
# Zeichenkette gefunden worden ist, die keine Tags enth„lt.
#
# Parameter : in | out Name Datentyp Beschreibung
# in data string Inhalt der Zeichenkette
#
# globaler Zugriff : -
#
#-----------------------------------------------------------------------------
proc parser_push {data} {
upvar ref_myStack myStack
lprepend myStack [string trim $data]
}
#-----------------------------------------------------------------------------
# Hauptprogramm
#-----------------------------------------------------------------------------
#TclXML-Parser initialisieren
if {[catch {package require xml 1.6}]} {
catch {puts stderr "Paket XML Version 1.7 konnte nicht gelesen werden\n"}
return -1
}
catch {rename xml::project {}}
set parser [xml::parser project -final 1 -reportempty 0 -elementstartcommand startTag -elementendcommand endTag -characterdatacommand parser_push]
#XML-Dokument laden
if {[file exists $xml_dokument] == 0} {
catch {puts stderr "Cannot load xmlfile"}
return -2
}
set tmpfile [open $xml_dokument r]
set xml_dokument [read $tmpfile]
close $tmpfile
#TclXML-Parser starten
$parser parse $xml_dokument
return
}
#!/usr/bin/tclsh8.0
exec tclsh80 $0 "$@"
##############################################################################
#
# Dateiname : search.cgi
# Import : tcl/cgi-args.tcl
# header.tcl
# access.tcl
# part.tcl
# htmlSites.tcl
#
# Prozeduren : -
#
# globale Variablen : -
#
##############################################################################
#-----------------------------------------------------------------------------
# Importanweisungen
#-----------------------------------------------------------------------------
source tcl/cgi-args.tcl
source header.tcl
source access.tcl
source part.tcl
source htmlSites.tcl
global val_fenstertitel val_sws val_semester val_stundenVorlesung
global val_stundenPruefung val_credit val_titel val_beschreibung
global val_kommentar val_mitarbeiter val_kategorie val_unterkategorie
global val_assessment val_referenz val_partner val_pruefungsordnungen
global val_hoererstatus val_sprache
global lit_titlanzeige lit_fenstertitel lit_sws lit_semester lit_stundenVorlesung
global lit_stundenPruefung lit_credit lit_titel lit_beschreibung
global lit_kommentar lit_mitarbeiter lit_kategorie lit_unterkategorie
global lit_assessment lit_referenz lit_partner lit_pruefungsordnung
global lit_hoererstatus lit_alle lit_sprache lit_vorlesungen
global lit_arbeitsaufwand lit_zurueck
#-----------------------------------------------------------------------------
# Hauptprogramm
#-----------------------------------------------------------------------------
#Ermittlung der CGI-Parameter
get_cgi_input
set request [get_cgi_argl]
set val_seite [join [get_cgi_arg seite]]
set val_language [join [get_cgi_arg language]]
set val_kategorie [join [get_cgi_arg kategorie]]
set val_unterkategorie [join [get_cgi_arg unterkategorie]]
set val_titel [join [get_cgi_arg titel]]
set val_semester [join [get_cgi_arg semester]]
set val_assessment [join [get_cgi_arg assessment]]
set val_mitarbeiter [join [get_cgi_arg mitarbeiter]]
set val_pruefungsordnung [join [get_cgi_arg pruefungsordnung]]
set val_hoererstatus [join [get_cgi_arg hoererstatus]]
set cgi_script $env(SCRIPT_NAME)
#Indexstrukturen und Literale einlesen
load "index//" $all_lists $all_arrays
init_literale "config//config_${val_language}.txt" $all_literale
#Kopfzeilen mit Auswahlliste erstellen
set head ""
append head "| [createHREF $lit_sprache seite A $cgi_script $request] | [allChange $val_language $lit_alle] | [createHREF $lit_hoererstatus seite I $cgi_script $request ] | [allChange $val_hoererstatus $val_hoererstatus ] | ||
| [createHREF $lit_pruefungsordnung seite E $cgi_script $request] | [allChange $val_pruefungsordnung $lit_alle] | [createHREF $lit_kategorie seite C $cgi_script $request] | [allChange $val_kategorie $lit_alle] | [createHREF $lit_unterkategorie seite D $cgi_script $request] | [allChange $val_unterkategorie $lit_alle] |
| [createHREF $lit_semester seite F $cgi_script $request] | [allChange $val_semester $lit_alle] | [createHREF $lit_mitarbeiter seite G $cgi_script $request] | [allChange $val_mitarbeiter $lit_alle] | [createHREF $lit_assessment seite H $cgi_script $request] | [allChange $val_assessment $lit_alle] |
| . | |||||
| [createHREF $lit_titelanzeige seite 0 $cgi_script $request] | [createHREF $lit_zurueck language $val_language $cgi_script $standard_request_list] |
##############################################################################
#
# Dateiname : access.tcl
# Import : -
# Beschreibung : Prozeduren, um auf die Indexstrukturen zugreifen zu k”nnen
# Die Prozeduren getValues, getKey und getmyKey sind Universal-
# routinen und werden von allen anderen Prozeduren benutzt.
#
# Prozeduren : getValues {ref_array keypatter ref_values}
# getKey {ref_array keypatter value ref_result art}
# getmyKey {ref_array keypatter ref_keys delete}
#
# Gruppe I
# getSemester {vid}
# getStundenVorlesung {vid}
# getStundenPruefung {vid}
# getCredit {vid}
# getSws {vid}
# getAssessment {lang vid}
# getKategorie {lang vid}
# getUnterkategorie {lang vid}
# getTitel {lang id}
# getBeschreibung {lang vid}
# getKommentar {lang vid}
#
# Gruppe II
# getReferenz {vid}
# getPartner {vid}
# getLanguage {vid}
# getPruefungsordnung {vid}
# getMitarbeiter {vid}
#
# getPruefungsordnungsInfo {pid vid ref_ss ref_ws}
# getMitarbeiterInfo {vid kuerzel ref_name ref_titel ref_url ref_toDo}
#
# Gruppe III
# getSemesterIDs {topic}
# getStundenVorlesungIDs {topic}
# getStundenPruefungIDs {topic}
# getCreditIDs {topic}
# getSwsIDs {topic}
# getKategorieIDs {lang topic}
# getUnterkategorieIDs {lang topic}
# getAssessmentIDs {lang topic}
# getTitelID {lang topic}
# getPruefungsordnungsIDs {topic}
# getLanguageIDs {topic}
# getMitarbeiterIDs {topic}
#
# Gruppe IV
# getAllSemester {}
# getAllStundenVorlesung {}
# getAllStundenPruefung {}
# getAllCredits {}
# getAllSws {}
# getAllKategorien {language}
# getAllUnterkategorien1 {language}
# getAllUnterkategorien2 {language kategorie}
# getAllAssessments {language}
# getAllTitel {language}
# getAllLanguages {}
# getAllPruefungsordnungen {}
# getAllMitarbeiter {}
# getAllHoererStati {}
# getAllIDs {}
#
# rueck {now}
# allChange {data default}
# globale Variablen : -
#
##############################################################################
#-----------------------------------------------------------------------------
# Modulname : getValues
# Beschreibung : Gibt die Werte des assoziativen Arrays aus, wenn
# das Muster auf den Schlssel paát
#
# Parameter : in | out Name Datentyp Beschreibung
# in|out ref_array array Arrayindexstruktur
# in keypatter string Muster, das im Schlssel
# des Arrays enthalten sein muá
# in|out ref_valuelist list Ergebnis
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# alle Indexstrukturen + -
#
#-----------------------------------------------------------------------------
proc getValues {ref_array keypatter ref_valuelist} {
upvar $ref_array array
upvar $ref_valuelist result
set result ""
# andere Schleifen auch so ab„ndern
foreach index [array names array $keypatter] {
set zw $array(${index})
if {[lsearch $result $zw] == -1 } {
lappend result $zw
}
}
return
}
#-----------------------------------------------------------------------------
# Modulname : getKey
# Beschreibung : Gibt alle Schlssel der Indexstruktur zurck, auf die
# das Muster paát und in deren Liste der Wert vorkommt.
#
# Parameter : in | out Name Datentyp Beschreibung
# in|out ref_array array Arrayindexstruktur
# in keypatter string Muster, das im Schlssel
# des Arrays enthalten sein muá
# in value string
# in|out ref_result list Ergebnis
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getKey {ref_array keypatter value ref_result art} {
upvar $ref_array array
upvar $ref_result result
set result ""
foreach index [array names array $keypatter] {
if { [lsearch $array($index) $value] > -1 } {
switch $art {
1 { set a ""
set r ""
set b ""
regexp {([^_]+)_([^_]+)} $index a b r
set result $r
}
2 { set a ""
set b ""
set c ""
set d ""
set r ""
regexp {([^_]+)_([^_]+)_([^_]+)} $index a b c r
set result $r
}
default { set result $index }
}
}
}
set result [join $result]
return
}
proc rueck {now} {
global tableDefault
if {[string compare [string trim $now] ""] == 0} {
return $tableDefault
} else {
return $now
}
}
#-----------------------------------------------------------------------------
# Modulname : getmyKey
# Beschreibung : Gibt eine Liste von Schlssel eines assoziativen Arrays
# zurck, auf die das Muster zutrifft.
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
#
#-----------------------------------------------------------------------------
proc getmyKey {ref_array keypatter ref_keys delete} {
upvar $ref_array array
upvar $ref_keys result
set result ""
# andere Schleifen auch so ab„ndern
if { $delete != 0 } {
foreach index [array names array $keypatter] {
set a ""
set c ""
set r ""
set b ""
switch $delete {
1 { regexp {([^_]+)} $index a r }
2 { regexp {([^_]+)_([^_]+)} $index a b r }
3 { regexp {([^_]+)_([^_]+)_([^_]+)} $index a b c r }
}
if {[lsearch $result $r] == -1 } {
lappend result $r
}
}
} else {
set result [array names array $keypatter]
}
return
}
#-----------------------------------------------------------------------------
# Modulname : Gruppe II
# Beschreibung : Ermittlung der zu einer bestimmten VeranstaltungsID geh”renden
# Daten
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getSemester {vid} {
global semester
set result ""
getKey semester "*" $vid result 0
return $result
}
proc getStundenVorlesung {vid} {
global stundenVorlesung
set result ""
getKey stundenVorlesung "*" $vid result 0
return $result
}
proc getStundenPruefung {vid} {
global stundenPruefung
set result ""
getKey stundenPruefung "*" $vid result 0
return $result
}
proc getCredit {vid} {
global credits
set result ""
getKey credits "*" $vid result 0
return $result
}
proc getSws {vid} {
global sws
set result ""
getKey sws "*" $vid result 0
return $result
}
proc getAssessment {lang vid} {
global assessment
set result ""
getKey assessment "${lang}_*" $vid result 1
return $result
}
proc getKategorie {lang vid} {
global kategorie
set result ""
getKey kategorie "${lang}_*" $vid result 1
return $result
}
proc getUnterkategorie {lang vid} {
global unterKategorie
set result ""
getKey unterKategorie "${lang}_*" $vid result 2
return $result
}
proc getTitel {lang vid} {
global titel
set result ""
getValues titel "${lang}_${vid}" result
return [join [join $result]]
}
proc getBeschreibung {lang vid} {
global beschreibung
set result ""
getValues beschreibung "${lang}_${vid}" result
return [join [join $result]]
}
proc getKommentar {lang vid} {
global kommentar
set result ""
getValues kommentar "${lang}_${vid}" result
return [join $result]
}
#-----------------------------------------------------------------------------
# Modulname : Gruppe II
# Beschreibung : Ermittlung der zu einer bestimmten VeranstaltungsID geh”renden
# Daten
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getReferenz {vid} {
global referenz
set result ""
getValues referenz "$vid" result
return [join $result]
}
proc getPartner {vid} {
global partnerveranstaltung
set result ""
getValues partnerveranstaltung "$vid" result
return [join $result]
}
proc getLanguage {vid} {
global lang
set result ""
getValues lang "$vid" result
return $result
}
proc getPruefungsordnung {vid} {
global pruefungsordnung
set result ""
getmyKey pruefungsordnung "*_${vid}" result 1
return $result
}
proc getMitarbeiter {vid} {
global mitarbeiter id
set resultList ""
foreach index [array names mitarbeiter] {
getMitarbeiterInfo $index z a b c d
if { [lsearch $d $vid] > -1 } {
lappend resultList [join $index "_"]
}
}
return $resultList
}
proc getMitarbeiterPlusHREF {vid} {
global mitarbeiter id
set resultList ""
foreach index [array names mitarbeiter] {
getMitarbeiterInfo $index z a b c d
if { [lsearch $d $vid] > -1 } {
lappend resultList <a href=${c}>${a}</a>
}
}
return $resultList
}
#-----------------------------------------------------------------------------
# Modulname : getPruefungsordnungsInfo
# Beschreibung : Ermittelt die Daten einer bestimmten Prfungsordnung
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getPruefungsordnungsInfo {pid vid ref_ss ref_ws} {
global pruefungsordnung
upvar $ref_ss ss
upvar $ref_ws ws
set result ""
getValues pruefungsordnung "${pid}_${vid}" result
set result [join $result]
set ss [lindex $result 0]
set ws [lindex $result 1]
return
}
proc getPruefungsordnungen {vid val_hoererstatus} {
global pruefungsordnung
set resultList ""
foreach pid [getAllPruefungsordnungen] {
set ss ""
set ws ""
getPruefungsordnungsInfo $pid $vid ss ws
switch $val_hoererstatus {
ss { if {[string compare $ss ""] == 0} {set ss "-"}
lappend resultList [list $pid $ss] }
ws { if {[string compare $ws ""] == 0} {set ws "-"}
lappend resultList [list $pid $ws] }
}
}
return $resultList
}
#-----------------------------------------------------------------------------
# Modulname : getMitarbeiterInfo
# Beschreibung : Ermittelt die Daten eines bestimmten Mitarbeiters
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getMitarbeiterInfo {id ref_kuerzel ref_name ref_titel ref_url ref_toDo} {
global mitarbeiter
upvar $ref_kuerzel kuerzel
upvar $ref_name name
upvar $ref_titel titel
upvar $ref_url url
upvar $ref_toDo toDo
set result ""
getValues mitarbeiter "$id" result
set result [join $result]
set kuerzel [lindex $result 0]
set name [lindex $result 1]
set titel [lindex $result 2]
set url [lindex $result 3]
set toDo [lindex $result 4]
return
}
#-----------------------------------------------------------------------------
# Modulname : Gruppe III
# Beschreibung : Ermittelt s„mtliche VeranstaltungsID auf die das Thema paát
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getSemesterIDs {topic} {
global semester id
set result ""
if {[string compare $topic alle] != 0} {
getValues semester "$topic" result
} else {
set result $id
}
return [join $result]
}
proc getStundenVorlesungIDs {topic} {
global stundenVorlesung id
set result ""
if {[string compare $topic alle] != 0} {
getValues stundenVorlesung "$topic" result
} else {
set result $id
}
return $result
}
proc getStundenPruefungIDs {topic} {
global stundenPruefung id
set result ""
if {[string compare $topic alle] != 0} {
getValues stundenPruefung "$topic" result
} else {
set result $id
}
return $result
}
proc getCreditIDs {topic} {
global credits id
set result ""
if {[string compare $topic alle] != 0} {
getValues credits "$topic" result
} else {
set result $id
}
return $result
}
proc getSwsIDs {topic} {
global sws id
set result ""
if {[string compare $topic alle] != 0} {
getValues sws "$topic" result
} else {
set result $id
}
return $result
}
proc getKategorieIDs {lang topic} {
global kategorie id
set result ""
if {[string compare $topic alle] != 0} {
getValues kategorie "${lang}_${topic}" result
} else {
set result $id
}
return [join $result]
}
proc getKategorieUnterkategorieIDs {lang ober unter} {
global unterKategorie id
set result ""
if {[string compare $ober alle] == 0} {
set result $id
} else {
if {[string compare $unter alle] == 0} {
getValues unterKategorie "${lang}_${ober}_*" result
} else {
getValues unterKategorie "${lang}_${ober}_${unter}" result
}
}
return [join $result]
}
proc getAssessmentIDs {lang topic} {
global assessment id
set result ""
if {[string compare $topic alle] != 0} {
getValues assessment "${lang}_${topic}" result
} else {
set result $id
}
return [join $result]
}
#proc getTitelID {lang topic} {
# global titel id
# set result ""
# if {[string compare $topic alle] != 0} {
# getKeys titel "${lang}_*" $topic result 1
# } else {
# set result $id
# }
# return $result
#}
proc getPruefungsordnungsIDs {topic} {
global pruefungsordnung id
set resultList ""
if {[string compare $topic alle] != 0} {
getmyKey pruefungsordnung "${topic}_*" resultList 2
} else {
set resultList $id
}
return [join $resultList]
}
proc getLanguageIDs {topic} {
}
proc getMitarbeiterIDs {topic} {
global mitarbeiter id
set resultList ""
if {[string compare $topic alle] != 0} {
getMitarbeiterInfo $topic z a b c d
set resultList $d
} else {
set resultList $id
}
return [join $resultList]
}
#-----------------------------------------------------------------------------
# Modulname : Gruppe IV
# Beschreibung : Ausgabe aller relevanten Daten eines Themas
#
# Parameter : in | out Name Datentyp Beschreibung
# verschieden
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# jeweilige Indexstruktur + -
#
#-----------------------------------------------------------------------------
proc getAllSemester {} {
global semester
set result ""
getmyKey semester "?*" result 0
return [lsort -increasing $result]
}
proc getAllStundenVorlesung {} {
global stundenVorlesung
set result ""
getmyKey stundenVorlesung "?*" result 0
return [lsort -increasing $result]
}
proc getAllStundenPruefung {} {
global stundenPruefung
set result ""
getmyKey stundenPruefung "?*" result 0
return [lsort -increasing $result]
}
proc getAllCredits {} {
global credits
set result ""
getmyKey credits "?*" result 0
return [lsort -increasing $result]
}
proc getAllSws {} {
global sws
set result ""
getmyKey sws "?*" result 0
return [lsort -increasing $result]
}
proc getAllKategorien {language} {
global kategorie
set result ""
getmyKey kategorie "${language}_?*" result 2
return [lsort -increasing $result]
}
proc getAllUnterkategorien1 {language} {
global unterKategorie
set result ""
getmyKey unterKategorie "${language}_?*" result 3
return [lsort -increasing $result]
}
proc getAllUnterkategorien2 {language kategorie} {
global unterKategorie
set result ""
getmyKey unterKategorie "${language}_${kategorie}_?*" result 3
return [lsort -increasing $result]
}
proc getAllAssessments {language} {
global assessment
set result ""
getmyKey assessment "${language}_?*" result 2
return [lsort -increasing $result]
}
proc getAllTitel {language} {
global titel
set result ""
getValues titel "${language}_*" result
return [lsort -increasing $result]
}
proc getAllLanguages {} {
global lang
return [lsort -increasing $lang()]
}
proc getAllPruefungsordnungen {} {
global pruefungsordnung
return [lsort -increasing $pruefungsordnung()]
}
proc getAllMitarbeiter {} {
global mitarbeiter
set resultList {}
getmyKey mitarbeiter "?*" resultList 0
return [lsort -increasing $resultList]
}
proc getAllHoererStati {} {
global hoererStati
return [lsort -increasing $hoererStati]
}
proc getAllIDs {} {
global id
return $id
}
#-----------------------------------------------------------------------------
# Modulname : getIDs
# Beschreibung : Durchsucht die Indexstrukturen der Selektionskriterien und gibt
# die VeranstaltungsIDs zurck, auf die die ausgew„hlen Selektions-
# kriterien passen
#
# Parameter : in | out Name Datentyp Beschreibung
# x x x x
# x x x x
#
# globaler Zugriff : Variablenname Lesezugriff Schreibzugriff
# alle Indexstrukturen + -
#
#-----------------------------------------------------------------------------
proc getIDs {} {
global id semester kategorie unterKategorie assessment mitarbeiter pruefungsordnung
global val_language val_kategorie val_unterkategorie val_assessment val_mitarbeiter val_pruefungsordnung val_semester
#Ermittlung der in Frage kommenden IDs je Kategorie, wobei die krzeste Liste
#die erste Liste ist
set allLists {}
ordne allLists [getKategorieUnterkategorieIDs $val_language $val_kategorie $val_unterkategorie]
ordne allLists [getAssessmentIDs $val_language $val_assessment]
ordne allLists [getMitarbeiterIDs $val_mitarbeiter]
ordne allLists [getPruefungsordnungsIDs $val_pruefungsordnung]
ordne allLists [getSemesterIDs $val_semester]
set allX [llength $allLists]
foreach element [lindex $allLists 0] {
set tmp(${element}) { x }
}
foreach sublist [lrange $allLists 1 end] {
foreach element $sublist {
if { [array names tmp $element] != ""} {
lappend tmp(${element}) x
}
}
}
set resultList ""
foreach element [array names tmp] {
if { [llength $tmp(${element})] == $allX } {
lappend resultList $element
}
}
return $resultList
}
proc allChange {data default} {
if {[string compare $data alle] == 0} {
return $default
} else {
return $data
}
}
##############################################################################
#
# Dateiname : htmlSites.tcl
# Import : toolbox.tcl
# part.tcl
#
# Beschreibung : Module zum Erzeugen und Verarbeiten von HTML-Seiten
#
# Prozeduren : createStartSite {filename cgi_url}
# modell {liste}
# lersetze {liste topic new}
# datafields {rows cols ...
# aufzaehlung {header elements key seite request what}
# myaufzaehlung {language header ...
# htmljezeile {liste}
# getVeranstaltungsInfo {language vid array}
#
#
# globale Variablen : -
#
##############################################################################
#-----------------------------------------------------------------------------
# Importanweisungen
#-----------------------------------------------------------------------------
source toolbox.tcl
source part.tcl
#-----------------------------------------------------------------------------
# Modulname : createStartSite
# Beschreibung : Erzeugt eine HTML-Seite namens im Verzeichnis ,
# die ein CGI-Link enth„lt.
# Wenn Verzeichnis nicht existiert, wird neues angelegt.
#
# Fehlercodes : -1: Gleichnamige Datei existiert schon
#
#
# Parameter : in | out Name Datentyp Beschreibung
# in filename string Dateiname
# in cgi_url string URL des Links
#
#-----------------------------------------------------------------------------
proc createStartSite {filename cgi_url} {
if {[string compare [file exists ${filename}] 0] != 0} {
return -1
}
set text "
fenstertitel
<a href=${cgi_url}>klick hier</a>
"
set tmpfile [open $filename w]
puts $tmpfile $text
close $tmpfile
return 0
}
#-----------------------------------------------------------------------------
# Modulname : modell
# Beschreibung : Ersetzt im String alle Leerzeichen durch einen Unterstrich
# bzw. dem Pluszeichen.
#
# Parameter : in | out Name Datentyp Beschreibung
# in text string zu modifizierender String
#
# Rckgabewert : Modifizierter String
#
#-----------------------------------------------------------------------------
proc mykonform {text} {
set argl [split $text " "]
return [join $argl "_"]
}
proc konform {text} {
set argl [split $text " "]
return [join $argl "+"]
}
#-----------------------------------------------------------------------------
# Modulname : modell
# Beschreibung : Erstellt eine CGI-Anfrage aus einer Liste, die wie folgt auf-
# gebaut ist, wobei Listen, die per CGI bergeben werden sollen,
# durch Pluszeichen verbunden werden.
# set liste { {key value} {key1 value1} ... {keyn valuen} }
# modell $liste -> key=value key1=value1 ... keyn=valuen
#
# Parameter : in | out Name Datentyp Beschreibung
# in liste Liste zu modifizierende Liste
#
#-----------------------------------------------------------------------------
proc modell {liste} {
set result ""
for {set i 0} {$i < [llength $liste]} {incr i} {
set sublist [lindex $liste $i]
append result [lindex $sublist 0] = [konform [lindex $sublist 1]] &
}
return [string range $result 0 [expr [string length $result] - 2]]
}
#-----------------------------------------------------------------------------
# Modulname : lersetze
# Beschreibung : Ersetzt in einer Liste, die wie folgt aufgebaut ist, den
# Wert einer Subliste.
# set liste { {key value} {key1 value1} ... {keyn valuen} }
# set new [lersetze $liste key1 xx]
# puts $new -> { {key value} {key1 xx} ... {keyn valuen} }
#
# Parameter : in | out Name Datentyp Beschreibung
# in liste liste zu modifizierende Liste
# in topic string Schlssel (im Beispiel key1)
# in new string neuer Wert (im Beispiel xx)
#
# Rckgabewert : modifizierte Liste
#-----------------------------------------------------------------------------
proc lersetze {liste topic new} {
set i 0
while {$i <= [llength $liste]} {
set sublist [lindex $liste $i]
if {[string compare [lindex $sublist 0] $topic] == 0} {
set newSublist [lreplace $sublist 1 1 $new]
set liste [lreplace $liste $i $i $newSublist]
break
# Annahme keine weiteren Sublisten mit gleichem Key
}
incr i
}
if {[string compare $topic language]} {
}
return $liste
}
#-----------------------------------------------------------------------------
# Modulname : aufzaehlung
# Beschreibung : Erstellt die Auswahlliste fr das Selektionskriterium
#
# Parameter : in | out Name Datentyp Beschreibung
# in header string šberschrift der Auswahlliste
# in elements list Elemente die aufgelistet werden sollen
# in request list Liste der aktuellen CGI-Parameter (Sublisten)
# in key string erstes Element einer Subliste
# gibt an, welches nachfolgende Element ersetzt werden soll
# in seite string zweites Element einer Subliste
# neuer Wert
# in what string erstes Element einer Subliste
# in default string zweites Element einer Subliste
#
# Rckgabewert : string (HTML-Seite)
#
#-----------------------------------------------------------------------------
proc aufzaehlung {header elements key seite request what default} {
global cgi_script
set text "
$header
"
set request [lersetze $request seite $seite]
#Listeneintrag: alle Elemente ausgeben
#bei Sprachauswahl und Anfeanger Link "alle" nicht mit anzeigen
if { ([string compare $what language] != 0) && ([string compare $what hoererstatus] != 0) } {
set request [lersetze $request $what alle]
append text "<a href =$cgi_script?[modell $request]>${default}</a>"
}
set unsortedList {}
foreach index $elements {
set request [lersetze $request $what $index]
#Tcl-Sortierfunktion ausnutzen
set info "<a href=$cgi_script?[modell $request]> ${index}</a>"
lappend unsortedList [list ${index} $info ]
}
# sortiere Listen in aufsteigender Reihenfolge anhand des Titels
set sortedList [lsort -index 0 -increasing $unsortedList]
# Titelangabe in den Sublisten entfernen
foreach element $sortedList {
append text [lindex $element 1]
}
return $text
}
#-----------------------------------------------------------------------------
# Modulname : myaufzaehlung
# Beschreibung : Erstellt die Auswahlliste fr das Selektionskriterium
#
# Parameter : in | out Name Datentyp Beschreibung
# in header string šberschrift der Auswahlliste
# in elements list Elemente die aufgelistet werden sollen
# in request list Liste der aktuellen CGI-Parameter (Sublisten)
# in key string erstes Element einer Subliste
# gibt an, welches nachfolgende Element ersetzt werden soll
# in seite string zweites Element einer Subliste
# neuer Wert
# in what string erstes Element einer Subliste
# in default string zweites Element einer Subliste
#
# Rckgabewert : string (HTML-Seite)
#
#-----------------------------------------------------------------------------
proc myaufzaehlung {language header elements key seite request what hoerer default} {
global cgi_script
set text "
$header
"
set request [lersetze $request seite $seite]
#Listeneintrage: alle Elemente ausgeben
set request [lersetze $request titel alle]
set request [lersetze $request $what $elements]
append text "<a href=${cgi_script}?[modell $request]>${default}</a>"
set unsortedList {}
foreach index $elements {
set currTitle [join [getTitel $language $index]]
set request [lersetze $request $what $index]
#Tcl-Sortierfunktion ausnutzen
set info " <a href=${cgi_script}?[modell $request]>${currTitle}</a>"
lappend unsortedList [list $currTitle $info ]
}
# sortiere Listen in aufsteigender Reihenfolge anhand des Titels
set sortedList [lsort -index 0 -increasing $unsortedList]
# Titelangabe in den Sublisten entfernen
foreach element $sortedList {
append text [lindex $element 1]
}
return $text
}
#-----------------------------------------------------------------------------
# Modulname : getVeranstaltungsInfo
# Beschreibung : Gibt den Body der HTML-Veranstaltungsseite zurck
#
# Parameter : in | out Name Datentyp Beschreibung
# in language string Sprache, der sprachab-
# h„ngigen Anteile der zu
# generierenden HTML-Seite
# in vid string Veranstaltungsnummer
#
# globaler Zugriff : Bezeichner und Werte
#
#-----------------------------------------------------------------------------
proc max {v1 v2} {
if {$v1 > $v2} {
return $v1
}
return $v2
}
proc getVeranstaltungsInfo3 {language vid} {
global val_fenstertitel val_sws val_semester val_stundenVorlesung
global val_stundenPruefung val_credit val_titel val_beschreibung
global val_kommentar val_mitarbeiter val_kategorie val_unterkategorie
global val_assessment val_referenz val_partner val_pruefungsordnungen
global val_hoererstatus val_sprache
global lit_fenstertitel lit_sws lit_semester lit_stundenVorlesung
global lit_stundenPruefung lit_credit lit_titel lit_beschreibung
global lit_kommentar lit_mitarbeiter lit_kategorie lit_unterkategorie
global lit_assessment lit_referenz lit_partner lit_pruefungsordnung
global lit_hoererstatus lit_alle lit_sprache lit_vorlesungen
global lit_arbeitsaufwand
#Anzahl Spalten fr Fachbereiche
set cntFachbereiche [llength ${val_pruefungsordnungen}]
# wenn z.B. keine Fachbereiche vorhanden, damit unterkategorie eine Spalte erh„lt und
# Tabellenaufbau in Ordnung bleibt
set col2 [max 1 ${cntFachbereiche}]
set text ""
append text "
$lit_titel:
$val_titel
$lit_kategorie /
$lit_unterkategorie:
$val_kategorie
$val_unterkategorie
$lit_credit
$lit_semester / $lit_sws
$lit_mitarbeiter
$lit_assessment "
if {$cntFachbereiche > 0} {
foreach sublist $val_pruefungsordnungen {
append text "[lindex $sublist 0] "
}
} else {
for { set i 0 } { $i < $col2 } {incr i} {
append text " "
}
}
append text "
$val_credit
$val_semester / $val_sws
$val_mitarbeiter
$val_assessment "
if {$cntFachbereiche > 0} {
foreach sublist $val_pruefungsordnungen {
append text "[lindex $sublist 1] "
}
} else {
for { set i 0 } { $i < $col2 } {incr i} {
append text " "
}
}
append text "
$lit_beschreibung:
$val_beschreibung
$lit_referenz
$val_referenz
$lit_kommentar:
${val_partner}$val_kommentar
$lit_arbeitsaufwand:
$lit_stundenVorlesung: $val_stundenVorlesung
$lit_stundenPruefung: $val_stundenPruefung
"
return $text
}
#-----------------------------------------------------------------------------
# Modulname : htmljezeile
# Beschreibung : Gibt einen String zurck, der aus den Elementen einer Liste
# besteht, deren Elemente mit
verbunden sind.
#
# Parameter : in | out Name Datentyp Beschreibung
# in liste liste Liste deren Elemente verbunden werden sollen
#
#-----------------------------------------------------------------------------
proc htmljezeile {liste} {
set text ""
foreach element $liste {
append text ${element}
}
return $text
}
proc htmllinkjezeile {liste cgi_script old_request} {
set text ""
foreach element $liste {
append text "[list <a href=${cgi_script}?[modell [lersetze $old_request titel [lindex $element 0]]]]>[mykonform [lindex $element 1]]</a>
"
}
return $text
}
##############################################################################
#
# Dateiname : toolbox.tcl
# Import : -
# Beschreibung : Funktionsbibliothek
#
# Prozeduren : car {liste}
# cdr {liste}
# lprepend {ref_liste element}
# push {ref_stack}
# pull {ref_stack}
# allEqualList {list1 list2}
# sortSublist {listenliste}
#
# globale Variablen : -
#
##############################################################################
#-----------------------------------------------------------------------------
# Modulname : car
# Beschreibung : Der Rckgabewert ist das erste Element der Liste .
# Wenn die Liste leer ist, wird ein leerer String zurckge-
# liefert.
#
# Parameter : in | out Name Datentyp Beschreibung
# in liste Liste Liste mit Elementen
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc car {liste} {
return [lindex $liste 0] }
#-----------------------------------------------------------------------------
# Modulname : cdr
# Beschreibung : Gibt die Liste vermindert um deren ersten Element
# zurck. Wenn die Liste leer ist, wird die leere Liste
# zurckgeliefert.
#
# Parameter : in | out Name Datentyp Beschreibung
# in liste Liste Liste mit Elementen
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc cdr {liste} {
return [lrange $liste 1 end] }
#-----------------------------------------------------------------------------
# Modulname : lprepend
# Beschreibung : Fgt das Element an den Kopf der Liste
# ein.
#
# Parameter : in | out Name Datentyp Beschreibung
# in/out ref_liste Liste Liste, in die das
# Element eingefgt
# werden soll
# in element Element, das in die
# Liste eingefgt werden
# soll.
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc lprepend {ref_liste element} {
upvar $ref_liste liste
set liste [linsert $liste 0 $element]
return
}
#-----------------------------------------------------------------------------
# Modulname : lprepend
# Beschreibung : Fgt ein Element an das Ende der Liste
# an.
#
# Parameter : in | out Name Datentyp Beschreibung
# in/out ref_liste Liste Liste, in die das
# Element eingefgt
# werden soll
# in element Element, das in die
# Liste eingefgt werden
# soll.
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc prepend {ref_text element} {
upvar $ref_text text
append element $text
set text $element
return
}
#-----------------------------------------------------------------------------
# Modulname : push
# Beschreibung : Fgt den getrimmten String an den Kopf der Liste
# ein. (Stackfunktion)
#
# Parameter : in | out Name Datentyp Beschreibung
# in/out ref_stack Liste Liste, in die das
# Element eingefgt
# werden soll
# in data Element, das in die
# Liste eingefgt werden
# soll.
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc push {ref_stack data} {
upvar $ref_stack myStack
lprepend myStack [string trim $data]
return
}
#-----------------------------------------------------------------------------
# Modulname : pull
# Beschreibung : L”scht das erste Element aus der Referenzliste
# und gibt es als Funktionsrckgabewert zurck. (Stackfunktion)
#
# Parameter : in | out Name Datentyp Beschreibung
# in/out ref_stack Liste Liste, in die das
# Element eingefgt
# werden soll
# in element Element, das in die
# Liste eingefgt werden
# soll.
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc pull {ref_stack} {
upvar $ref_stack myStack
set data [car $myStack]
set myStack [cdr $myStack]
return $data
}
#-----------------------------------------------------------------------------
# Modulname : allEqualList
# Beschreibung : Gibt die Schnittmenge der Elemente der Listen und
# zurck.
#
# Parameter : in | out Name Datentyp Beschreibung
# in list1 Liste Vergleichsliste 1
# in list2 Liste Vergleichsliste 2
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc allEqualList {list1 list2} {
set returnList ""
foreach element1 $list1 {
set isin 0
foreach element2 $list2 {
if {[string compare $element1 $element2] == 0} {
set isin 1
break
# nicht notwendig die restliche Liste zu durchsuchen, wenn bereits Element in der Liste gefunden
}
}
if { ($isin == 1) && ([lsearch $returnList $element1] == -1) } {
lappend returnList $element1
}
}
return $returnList
}
#-----------------------------------------------------------------------------
# Modulname : sortSublist
# Beschreibung : Die Liste besteht aus mehreren Sublisten.
# Es wird eine neue Liste zurckgegeben in der die Sublisten
# anhand ihrer L„nge nach aufsteigend sortiert sind.
#
# Parameter : in | out Name Datentyp Beschreibung
# in listenliste Liste Liste mit Sublisten
#
# Rckgabewert und
# Fehlerbehandlung : siehe Modulbeschreibung
#
#-----------------------------------------------------------------------------
proc sortSublist {listenliste} {
# erzeuge neue Liste, die aus zweielementigen Sublisten besteht, wobei das
# zweite Element eine Subliste der und das erste Element die
# L„nge dieser Subliste darstellt
set allListsLength ""
foreach element $listenliste {
lappend allListsLength [list $element [llength $element]]
}
# sortiere Listen in aufsteigender Reihenfolge anhand der L„ngenangabe
set allListsLength [lsort -increasing -index 1 $allListsLength]
# L„ngenangabe in den Sublisten entfernen
set result ""
foreach element $allListsLength {
lappend result [lindex $element 0]
}
return $result
}
#-----------------------------------------------------------------------------
# Modulname : ordne
# Beschreibung : H„ngt new_list an den Kopf der Liste an, wenn
# sie krzer ist, ansonsten an das Ende
#
# Parameter : in | out Name Datentyp Beschreibung
# in/out ref_list Liste alte Liste
# in new_list Liste anzuh„ngende Liste
#
#-----------------------------------------------------------------------------
proc ordne {ref_result new_list} {
upvar $ref_result result
if {[llength $new_list] < [llength [lindex $result 0]]} {
lprepend result $new_list
} else {
lappend result $new_list
}
return
}
##############################################################################
# Import : locale
# DBI
# Datei : gen_xml.pl
# Beschreibung : Generiert aus der Datenbank ein XML-Dokument mit allen
# Veranstaltungen
#
#
# Programmierer : Mario Busche
# Änderungen : Datum Beschreibung
# 20.07.1999 Erstellung (letzte Änderung)
##############################################################################
use locale;
use strict; # damit Variablen mit my definiert werden muessen
use DBI; # Datenbankschnittstelle
# String mit allen aktuellen Studienordnungen.wird in den SQL-Statements zur Selektion bnutzt
my $AktuellePO = "('AI10.0', 'DI10.0', 'II10.0', 'MI10.0', 'PI10.0', 'WI10.0', 'EA10.4', 'EA12.0', 'IA10.3', 'IA12.0', 'PA10.2', 'PA12.0')";
my $AnzahlVeranstaltungen = 0;
my $ODBC = 'dbi:ODBC:mbu';
my $data = "";
# Verbindung zur Datenbank herstellen
my $dbh = DBI->connect( $ODBC,
{
RaiseError => 1
}
)
|| die "Database connection not made: $DBI::errstr";
#Puffer fuer BLOB Felder setzen, damit diese auch gelesen werden
$dbh->{LongReadLen} = 3048;
#Variablen fuer die Tabelle Veranstaltungen definieren
my( $Semester, $Ver_ID_Veranstaltung, $SWS, $ECTS_Grade, $ECTS_Punkte, $ECTS_Assessment,
$ECTS_LT_Stunden, $ECTS_PE_Stunden, $ID_Veranstaltung, $Dummy);
# Selektiere alle Veranstaltungen der aktuellen Stdudienordnungen
my $sql = "SELECT DISTINCT v.ID_Veranstaltung, v.Semester, v.Ver_ID_Veranstaltung, v.SWS,\
v.ECTS_Grade, v.ECTS_Assessment, v.ECTS_LT_Studen, v.ECTS_PE_Studen,\
v.name\
FROM veranstaltungen v,\
veranstaltung_gruppe vg,\
fb_obergruppen_soplan fos,\
prufungsordnung po\
WHERE v.id_veranstaltung = vg.id_veranstaltung\
and vg.fogr_id = fos.fogr_id\
and fos.prufungsordnung_id = po.prufungsordnung_id\
and po.po_nr in ".$AktuellePO."\
ORDER BY v.name";
my $sthVeranstaltungen = $dbh->prepare( $sql );
$sthVeranstaltungen->execute();
$sthVeranstaltungen->bind_columns( undef,
\$ID_Veranstaltung,
\$Semester,
\$Ver_ID_Veranstaltung,
\$SWS,
\$ECTS_Grade,
\$ECTS_Assessment,
\$ECTS_LT_Stunden,
\$ECTS_PE_Stunden,
\$Dummy);
# XML Datei oeffnen
open (fh, "> veranstaltungen.xml");
# Header der XML-Datei generieren
$data = << "HEADER";
HEADER
#while( $sthVeranstaltungen->fetch() && ($AnzahlVeranstaltungen < 10) ) {
while( $sthVeranstaltungen->fetch() ) {
++$AnzahlVeranstaltungen;
print "$AnzahlVeranstaltungen\n";
# $data .= "\t\n";
$data .= "\t\t$SWS \n";
$data .= "\t\t$ECTS_Grade \n";
$data .= "\t\t$ECTS_LT_Stunden \n";
$data .= "\t\t$ECTS_PE_Stunden \n";
# Textfelder je Sprache einfuegen
my( $Name, $Category, $SubCategory, $Description, $Comments, $Sprache);
$sql = "SELECT * FROM Veranstaltungen_T WHERE ID_Veranstaltung = ?";
my $sthZusatz = $dbh->prepare( $sql );
$sthZusatz->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER );
$sthZusatz->execute();
$sthZusatz->bind_columns( undef,
\$Dummy,
\$Sprache,
\$Name,
\$Category,
\$SubCategory,
\$Description,
\$Comments);
while( $sthZusatz->fetch() ) {
$data .= "\t\t\n";
$data .= "\t\t\t".&normalize($Category)." \n";
$data .= "\t\t\t".&normalize($SubCategory)." \n";
$data .= "\t\t\t".&normalize($Name)." \n";
$data .= "\t\t\t".&normalize($Description)." \n";
$data .= "\t\t\t".&normalize($Comments)." \n";
# Assessment je Sprache einfuegen
my( $AssessmentName);
my $sql = "SELECT * FROM Assessment WHERE ID_Assessment=? AND ID_Sprache = ?";
my $sthAssessment = $dbh->prepare( $sql );
$sthAssessment->bind_param(1, $ECTS_Assessment);
$sthAssessment->bind_param(2, $Sprache);
$sthAssessment->execute();
$sthAssessment->bind_columns( undef,
\$Dummy,
\$Dummy,
\$AssessmentName);
$sthAssessment->fetch();
$data .= "\t\t\t".&normalize($AssessmentName)." \n";
$sthAssessment->finish();
$data .= "\t\t \n";
}
$sthZusatz->finish();
# Referenzen einfügen
my( $Reference);
$sql = "SELECT * FROM Veranstaltungen_R WHERE ID_Veranstaltung = ?";
my $sthReference = $dbh->prepare( $sql );
$sthReference->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER );
$sthReference->execute();
$sthReference->bind_columns(undef,
\$Dummy,
\$Dummy,
\$Reference);
while( $sthReference->fetch() ) {
$data .= "\t\t".&normalize($Reference)." \n";
}
$sthReference->finish();
# Mitarbeiter einfügen
my( $Kurzel, $Titel, $Vorname, $Nachname);
$sql = "SELECT m.Kurzel, m.Titel, m.Vorname, m.Nachname FROM Mitarbeiter m, MA_hat_Veranst v WHERE v.ID_Veranstaltung = ? AND m.Kurzel = v.Kurzel";
my $sthMitarbeiter = $dbh->prepare( $sql );
$sthMitarbeiter->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER);
$sthMitarbeiter->execute();
$sthMitarbeiter->bind_columns(undef,
\$Kurzel,
\$Titel,
\$Vorname,
\$Nachname);
while( $sthMitarbeiter->fetch() ) {
$Kurzel = lc($Kurzel);
$data .= "\t\t".&normalize($Nachname)."\n";
$data .= "\t\t \n";
}
$sthMitarbeiter->finish();
# zugeordnete Veranstaltung
if ( $Ver_ID_Veranstaltung != "" ) {
$sql = "SELECT name FROM Veranstaltungen";
my $sthV = $dbh->prepare( $sql );
$sthV->execute();
$sthV->bind_columns(undef,
\$Name);
$sthV->fetch();
$data .= "\t\t\n".&normalize($Name);
$data .= "\t\t \n";
$sthV->finish();
}
# Veranstaltungen eines Scheines suchen
my ($id_pfach, $ref_id);
$sql = "SELECT pf.id_pfach\
FROM veranstaltungen v,\
prufungsfach pf,\
unterfacher_studienordnung uf,\
stundenplan_veranstaltungen sv\
WHERE pf.id_pfach = uf.id_pfach\
and uf.id_ufach = sv.id_ufach\
and sv.id_veranstaltung = v.id_veranstaltung
and v.id_veranstaltung = ?";
my $sthV = $dbh->prepare( $sql );
$sthV->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER);
$sthV->execute();
$sthV->bind_columns( undef, \$id_pfach);
$sthV->fetch();
$sthV->finish();
$sql = "SELECT v.id_veranstaltung, v.name\
FROM veranstaltungen v,\
prufungsfach pf,\
unterfacher_studienordnung uf,\
stundenplan_veranstaltungen sv\
WHERE pf.id_pfach = uf.id_pfach\
and uf.id_ufach = sv.id_ufach\
and sv.id_veranstaltung = v.id_veranstaltung\
and v.id_veranstaltung <> ?\
and pf.id_pfach = ?";
$sthV = $dbh->prepare( $sql );
$sthV->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER);
$sthV->bind_param(2, $id_pfach, DBI::SQL_INTEGER);
$sthV->execute();
$sthV->bind_columns( undef, \$ref_id, \$Name);
while( $sthV->fetch() ) {
$data .= "\t\t\n".&normalize($Name);
$data .= "\t\t \n";
}
$sthV->finish();
# Pruefungsordnung
my( $po_nr, $ht_ws, $ht_ss);
$sql = "SELECT po.po_nr, sv.ht_ws, sv.ht_so \
FROM prufungsordnung po,\
prufungsfach pf,\
unterfacher_studienordnung uf,\
stundenplan_veranstaltungen sv\
WHERE po.prufungsordnung_id = pf.prufungsordnung_id\
and pf.id_pfach = uf.id_pfach\
and uf.id_ufach = sv.id_ufach\
and sv.id_veranstaltung = ?\
and po.po_nr in ".$AktuellePO."\
ORDER BY po.po_nr desc";
my $sthpo = $dbh->prepare( $sql );
$sthpo->bind_param(1, $ID_Veranstaltung, DBI::SQL_INTEGER);
$sthpo->execute();
$sthpo->bind_columns( undef, \$po_nr, \$ht_ws, \$ht_ss );
while( $sthpo->fetch() ) {
$data .= "\t\t$po_nr \n";
$ht_ws = "-" if $ht_ws == "";
$ht_ss = "-" if $ht_ss == "";
$data .= "\t\t\t $ht_ws \n";
$data .= "\t\t\t $ht_ss \n";
$data .= "\t\t \n";
}
$sthpo->finish();
$data .= "\t \n";
print fh $data;
$data = "";
}
$sthVeranstaltungen->finish();
$dbh->disconnect();
print fh " ";
close fh;
sub normalize {
my $string = @_[0];
if ($string eq "") {
$string = "-";
} else {
$string =~ s/[<>&']/&con_sonderzeichen($&)/ge;
}
return $string;
}
sub con_sonderzeichen {
my $char = @_[0]; #Sonderzeichen
SWITCH: {
if ($& eq "<") { $char = "<"; last SWITCH; }
if ($& eq ">") { $char = ">"; last SWITCH; }
if ($& eq "&") { $char = "&"; last SWITCH; }
if ($& eq "'") { $char = "'"; last SWITCH; }
}
return $char;
}
|
|
zurück:
|
Programmorganisation |