def kommunikation_verwaltung(self):
""" *Die Kommunikationsverwaltung wird aufgerufen* """
# Auflistung aller Kommunikationsgeräte
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='*',
filtern='dtKategorie="Kommunikation"')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('kommunikation_auflistung', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
knappheit=eintrag[6], mitglied=eintrag[7]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('kommunikation_auflistung',
datenliste)
else:
self.kontext.setContextProperty('kommunikation_auflistung', None)
# Auflistung aller Mitglieder
sql_anweisung = sql_anweisungen.sql(tabelle='tblMitglied', select='*')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('kommunikation_mitglieder', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0], name=eintrag[1],
vorname=eintrag[2]))
except:
datensatz.append(mitglied_objekt.Mitglied(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('kommunikation_mitglieder',
datenliste)
else:
self.kontext.setContextProperty('kommunikation_mitglieder', None)
self.kommunikation_gegenstaende_setzen_signal.emit()
def overlay_meldungen_aufbau(self):
""" *Die Meldungen für das Overlay werden aufgebaut*
**Beschreibung**
Methode welche alle benötigten/vorgesehenen Kontrollen/Tests durchführt
und diese ins Overlay schreibt.
"""
sql_anweisung = sql_anweisungen.sql(tabelle='tblMitglied')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
if mitglied_logik.medizinischeKontrolle(eintrag[14]):
datensatz.append(meldungen_objekt.Meldungen(
'Die medizinische Kontrolle für das Mitglied\n%s %s '
'ist abgelaufen' % (eintrag[1], eintrag[2])))
if mitglied_logik.restliche_stunden(eintrag[11]):
datensatz.append(meldungen_objekt.Meldungen(
'Das Mitglied %s %s hat nicht mehr\nviele freie Stunden'
' für Lehrgänge übrig' % (eintrag[1], eintrag[2])))
except:
datensatz.append(meldungen_objekt.Meldungen(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('meldungen_liste', datenliste)
self.meldungen_liste = datensatz
else:
self.kontext.setContextProperty('meldungen_liste', None)
def atemschutz_beschaedigt_bericht(self):
""" *Berichterstellung über beschädigte Atemschutzgeräte* """
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
filtern='dtKategorie="Atemschutz" AND dtZustand="beschädigt"',
select='*',
sortieren='dtBezeichnung')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
kontrolle=eintrag[5], knappheit=eintrag[6],
mitglied=eintrag[7]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
bericht = ""
try:
for atemschutz in datensatz:
bericht = bericht + '<p class="bericht">'
bericht = bericht + atemschutz.bezeichnung + "<br \>"
bericht = bericht + atemschutz.zustand + "<br \>"
bericht = bericht + "</p>"
except:
bericht = "<i>Keine Meldungen verfügbar</i>"
bericht_erstellung.html_bericht(daten=bericht,
benutzer="Inventarist")
def ausstattung_anzeigenVerstecken(self):
""" *Die Ausstattung wird angezeigt oder versteckt* """
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='idInventarnummer, dtBezeichnung, dtKategorie, '
'COUNT(dtBezeichnung) AS "Anzahl"',
filtern='idInventarnummer IN (SELECT fiInventarnummer'
' FROM tblFahrzeugAusstattung WHERE fiFahrzeugNummer=%s)' % (
self.fahrzeugID),
gruppieren='dtBezeichnung')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('ausstattung_auflistung', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[2], anzahl=eintrag[3]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('ausstattung_auflistung',
datenliste)
else:
self.kontext.setContextProperty('ausstattung_auflistung', None)
self.ausstattung_anzeigenVerstecken_signal.emit()
def ausrustung_bearbeiten(self):
""" *Das Menü zum bearbeiten der Ausrüstung eines Mitglieds*
**Beschreibung**
Das Menü zur Verwaltung der persönlichen Ausrüstung eines Mitglieds
wird gesetzt und aufgerufen.
Eine Liste mit allen nicht verwendeten Inventargegenständen wird
angezeigt und die momentane Ausrüstung eines Mitglieds wird angezeigt.
"""
try:
# Liste von nicht verwendeten Inventargegenständen wird erzeugt
inventar_liste = inventar.nicht_verwendete_inventargegenstaende(
self.datenbank_verbindung)
datensatz = []
for eintrag in inventar_liste:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[4], knappheit=eintrag[6],
anzahl=eintrag[8]))
inventarliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('inventar_liste', inventarliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('inventar_liste', None)
try:
# Liste aller Ausrüstungsgegenstände eines Mitglieds wird erzeugt
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
filtern='fiStammlistennummerAusrustung=%s' % self.schlussel)
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[4], knappheit=eintrag[6]))
ausrustung = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('ausrustung_liste', ausrustung)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('ausrustung_liste', None)
self.ausrustung_bearbeiten_signal.emit()
def fahrzeugliste_aufbauen(self):
""" *Fahrzeugliste wird aufgebaut und mit Daten gefüllt* """
sql_anweisung = sql_anweisungen.sql(tabelle='tblFahrzeug')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('fahrzeug_liste', None)
datensatz = []
# Instanz Variablen für Fahrzeug() und FahrzeugTyp() werden gesetzt
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(fahrzeug_objekt.Fahrzeug(
schlussel=eintrag[0],
kennzeichen=eintrag[1], bezeichnung=eintrag[2],
besatzung=eintrag[3], technisches_problem=eintrag[4],
kommentar=eintrag[5], tuv=eintrag[6],
werkstatt=eintrag[7], typ=eintrag[8]))
except:
datensatz.append(fahrzeug_objekt.Fahrzeug(None))
else:
self.kontext.setContextProperty('fahrzeug_liste', None)
# Liste aller Fahrzeug Typen wird erstellt
fahrzeug_typ_liste = ['MTW', 'TLF', 'TSF', 'LF', 'HTLF', 'GW', 'RW1',
'DLA', 'TLK', 'DLK', 'KTW', 'RTW', 'NAW',
'S.A.M.U.']
fahrzeug_typ_daten = []
for eintrag in fahrzeug_typ_liste:
fahrzeug_typ_daten.append(fahrzeug_objekt.FahrzeugTypListe(
typ=eintrag))
# Die Datensätze werden in ein 'QObject' verpackt
# und ins Listen Modell modelisiert
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
fahrzeug_typen = verpacken_modelisieren.list_verpackung_modelisieren(
fahrzeug_typ_daten)
# Die beiden Listen werden der QMLUI übergeben
self.kontext.setContextProperty('fahrzeug_liste', datenliste)
self.kontext.setContextProperty('fahrzeug_typ_liste', fahrzeug_typen)
def sonstige_gegenstaende_liste(self):
""" *Liste sonstiger Inventargegenstände wird generiert*
**Beschreibung**
Eine Liste aller Inventargegenständen welche nicht in eine der
Hauptkategorien passen wird generiert.
"""
sql_anweisung = sql_anweisungen.sql(
select="idInventarnummer, dtBezeichnung, dtKategorie, "
"dtKnappheit, dtGrosse, dtZustand, "
"dtKontrollDatum, fiStammlistennummerAusrustung, "
"COUNT(dtBezeichnung) AS 'Anzahl'",
tabelle="tblInventar",
filtern="dtKategorie NOT IN('Schlauche', 'Atemschutz', "
"'Kommunikation', 'Kleider', 'Schaummittel', 'Maschinerie', "
"'1.Hilfe')", gruppieren="dtKategorie, dtBezeichnung")
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('sonstige_gegenstaende', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[2], knappheit=eintrag[3],
anzahl=eintrag[8], groesse=eintrag[4],
zustand=eintrag[5], kontrolle=eintrag[6],
mitglied=eintrag[7]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('sonstige_gegenstaende',
datenliste)
else:
self.kontext.setContextProperty('sonstige_gegenstaende', None)
self.sonstige_liste_setzen_signal.emit()
def overlay_meldungen_aufbau(self):
""" *Die Meldungen für das Overlay werden aufgebaut*
**Beschreibung**
Methode welche alle benötigten/vorgesehenen Kontrollen/Tests durchführt
und diese ins Overlay schreibt.
"""
sql_anweisung = sql_anweisungen.sql(tabelle='tblFahrzeug')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('meldungen_liste', None)
datensatz = []
# Instanz Variablen für Fahrzeug() und FahrzeugTyp() werden gesetzt
if sql_resultate:
for eintrag in sql_resultate:
try:
if fahrzeug.tuvTest(eintrag[6]):
datensatz.append(meldungen_objekt.Meldungen(
'Der Tüv Test für das Fahrzeug \n%s %s ist abgelaufen' %
(eintrag[1], eintrag[2])))
if fahrzeug.werkTest(eintrag[7]):
datensatz.append(meldungen_objekt.Meldungen(
'Die Werkstattkontrolle für das Fahrzeug \n%s %s '
'ist abgelaufen' % (eintrag[1], eintrag[2])))
if fahrzeug.problemTest(eintrag[4]):
datensatz.append(meldungen_objekt.Meldungen(
'Für das Fahrzeug \n%s %s besteht ein Problem'
% (eintrag[1], eintrag[2])))
except:
datensatz.append(meldungen_objekt.Meldungen(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('meldungen_liste', datenliste)
else:
self.kontext.setContextProperty('meldungen_liste', None)
self.meldungen_liste = datensatz
def schlauch_gegenstaende_liste(self):
""" *Die Schlauch Verwaltung wird aufgerufen* """
try:
# Anzahl aller A Schläuche
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='COUNT(dtBezeichnung) AS "Anzahl"',
filtern='dtBezeichnung = "A Schlauch"')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
a_schlauch_anzahl = sql_resultate[0][0]
except:
a_schlauch_anzahl = 0
try:
# Anzahl aller B Schläuche
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='COUNT(dtBezeichnung) AS "Anzahl"',
filtern='dtBezeichnung = "B Schlauch"')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
b_schlauch_anzahl = sql_resultate[0][0]
except:
b_schlauch_anzahl = 0
try:
# Anzahl aller C Schläuche
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='COUNT(dtBezeichnung) AS "Anzahl"',
filtern='dtBezeichnung = "C Schlauch"')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
c_schlauch_anzahl = sql_resultate[0][0]
except:
c_schlauch_anzahl = 0
try:
# Anzahl aller D Schläuche
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='COUNT(dtBezeichnung) AS "Anzahl"',
filtern='dtBezeichnung = "D Schlauch"')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
d_schlauch_anzahl = sql_resultate[0][0]
except:
d_schlauch_anzahl = 0
try:
# Anzahl aller beschädigter Schläuche
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='COUNT(dtzustand) AS "Anzahl"',
filtern='dtKategorie = "Schlauche" AND dtZustand="beschädigt"')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
beschaedigt_schlauch_anzahl = sql_resultate[0][0]
except:
beschaedigt_schlauch_anzahl = 0
# Attribute der QMLUI zur Verfügung stellen
self.kontext.setContextProperty('a_schlauch_anzahl',
a_schlauch_anzahl)
self.kontext.setContextProperty('b_schlauch_anzahl',
b_schlauch_anzahl)
self.kontext.setContextProperty('c_schlauch_anzahl',
c_schlauch_anzahl)
self.kontext.setContextProperty('d_schlauch_anzahl',
d_schlauch_anzahl)
self.kontext.setContextProperty('beschaedigt_schlauch_anzahl',
beschaedigt_schlauch_anzahl)
# Anzahl der beschädigten Schläuche (Variable wird später im Programm
# benötigt)
self.beschaedigt_schlauch_anzahl = beschaedigt_schlauch_anzahl
# Liste aller Schläuche wird erstellt
sql_anweisung = sql_anweisungen.sql(select='*', tabelle='tblInventar',
filtern='dtKategorie ="Schlauche"',
sortieren='dtBezeichnung')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('schlauch_gegenstaende', None)
self.schlauch_liste_setzen_signal.emit()
return
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
knappheit=eintrag[6]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
schlauche = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('schlauch_gegenstaende', schlauche)
self.aktuelle_schlauch_liste = datensatz
else:
self.kontext.setContextProperty('schlauch_gegenstaende', None)
self.schlauch_liste_setzen_signal.emit()
def mitglied_info_setzen(self, mitglied):
""" *Die Informationen des ausgewäglten Mitglieds werden gesetzt*
**Parameter**
- mitglied: Verpackter Datensatz eines Mitglieds
"""
# Standard Mitglied Informationen
self.mitglied = mitglied
self.schlussel = mitglied.datensatz.schlussel
self.kontext.setContextProperty('mitglied_info_name',
mitglied.datensatz.name)
self.kontext.setContextProperty('mitglied_info_vorname',
mitglied.datensatz.vorname)
self.kontext.setContextProperty('mitglied_info_sozialnummer',
mitglied.datensatz.sozialnummer)
self.kontext.setContextProperty('mitglied_info_bday',
str(mitglied.datensatz.bday))
self.kontext.setContextProperty('mitglied_info_mobiltelefon',
mitglied.datensatz.mobiltelefon)
self.kontext.setContextProperty('mitglied_info_email',
mitglied.datensatz.email)
self.kontext.setContextProperty('mitglied_info_telefonnummer',
mitglied.datensatz.telefonnummer)
self.kontext.setContextProperty('mitglied_info_ortschaft',
mitglied.datensatz.ortschaft)
self.kontext.setContextProperty('mitglied_info_adresse',
mitglied.datensatz.adresse)
self.kontext.setContextProperty('mitglied_info_postleitzahl',
mitglied.datensatz.postleitzahl)
self.kontext.setContextProperty('mitglied_info_lehrgangsstunden',
mitglied.datensatz.lehrgangsstunden)
self.kontext.setContextProperty('mitglied_info_medi',
str(mitglied.datensatz.mediKontrolle))
self.kontext.setContextProperty('mitglied_info_apteinsatz',
mitglied.datensatz.apteinsatz)
self.kontext.setContextProperty('mitglied_info_aptatemschutz',
mitglied.datensatz.aptatemschutz)
# Lehrgänge eines Mitglieds setzen
try:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblAbsolvieren Ab, tblLehrgang Leh',
select='idLehrgang',
filtern='Ab.fiStammlistennummerAbsolvieren=%s AND '
'Ab.fiLehrgangLehrgang=Leh.idLehrgang' % (self.schlussel))
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(lehrgang_objekt.Lehrgang(
schlussel=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('mitglied_info_lehrgaenge',
datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('mitglied_info_lehrgaenge',
None)
# Auszeichnungen eines Mitglieds setzen
try:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblMitgliedsAuszeichnungen Mit, tblAuszeichnung Aus',
select='idAuszeichnung',
filtern='Mit.fiStammlistennummerAuszeichnung=%s AND '
'Mit.fiAuszeichnung=Aus.idAuszeichnung' % (self.schlussel))
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(auszeichnung_objekt.Auszeichnung(
auszeichnung=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('mitglied_info_auszeichnungen',
datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('mitglied_info_auszeichnungen',
None)
# Führerscheine eines Mitglieds setzen
try:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblMitgliederFührerscheine',
select='idFuehrerschein',
filtern='fiStammlistennummerFührerschein=%s' % (
self.schlussel))
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(fuhrerschein_objekt.Fuhrerschein(
schlussel=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('mitglied_info_fuhrerscheine',
datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('mitglied_info_fuhrerscheine',
None)
self.mitglied_info_setzen_signal.emit()
def anmelden(self):
""" *Der Benutzer wird im System angemeldet*
**Beschreibung**
Der Benutzer wird mit seinem angegebenem Benutzernamen und
Benutzerpasswort im System angemeldet. Abhängig davon welcher
Benutzername angegeben wurde, wird der Benutzer in seinen jeweiligen
Bereich weitergeleitet.
+------------------------+----------------+-------------------------+
| Benutzername | Passwort | Benutzerbereich |
+========================+================+=========================+
| admin | admin | Administrator |
+------------------------+----------------+-------------------------+
| inventarist | inventarist | Inventarist |
+------------------------+----------------+-------------------------+
| kommandant | kommandant | Inventarist, Kommandant |
| | | Maschinist, Sekretär |
+------------------------+----------------+-------------------------+
| maschinist | maschinist | Maschinist |
+------------------------+----------------+-------------------------+
| sekretaer | sekretaer | Sekretär |
+------------------------+----------------+-------------------------+
"""
# Sicherstellen dass eine Datenbankverbindung besteht
try:
self.verbinden(self.einstellungen_laden())
self.datenbank_verbindung
except AttributeError:
self.fehler_verbindung = True
self.konfigurieren()
return
benutzer = self.ui_objekt.property('edtLogin')
passwort = self.ui_objekt.property('edtPasswort')
sql_anweisung = sql_anweisungen.sql(
tabelle='tblBenutzer',
select='idBenutzernummer',
filtern='dtLogin="******" AND dtPasswort="%s"' % (benutzer,
passwort))
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
if not sql_resultate:
self.fehler_anmeldung_signal.emit()
elif benutzer == "admin":
from UI_Aufbau import admin
Admin = admin.QMLUI()
Admin.setWindowState(QtCore.Qt.WindowMaximized)
Admin.show()
self.hide()
elif benutzer == "kommandant":
from UI_Aufbau import kommandant
Kommandant = kommandant.QMLUI()
Kommandant.setWindowState(QtCore.Qt.WindowMaximized)
Kommandant.show()
self.hide()
elif benutzer == "sekretaer":
from UI_Aufbau import sekretaer
Sekretaer = sekretaer.QMLUI()
Sekretaer.setWindowState(QtCore.Qt.WindowMaximized)
Sekretaer.show()
self.hide()
elif benutzer == "inventarist":
from UI_Aufbau import inventarist
Inventarist = inventarist.QMLUI()
Inventarist.setWindowState(QtCore.Qt.WindowMaximized)
Inventarist.show()
self.hide()
elif benutzer == "maschinist":
from UI_Aufbau import maschinist
Maschinist = maschinist.QMLUI()
Maschinist.setWindowState(QtCore.Qt.WindowMaximized)
Maschinist.show()
self.hide()
def kommandant_bereich_aufbau(self, state_wechseln=True):
"""*Die Informationen für den Bereich des Kommandanten werden gesetzt*
**Beschreibung**
Eine Liste aller Mitglieder welche in der Datenbank abgespeichert sind
wird erstellt und gesetzt und die einzelnen Listen aller Lehrgänge,
Führerscheine und Auszeichnungen für die Auswahllisten werden erstellt
und gesetzt.
**Parameter**
- state_wechseln: *Boolean* Angabe ob nur die einzelnen Listen neu
erstellt werden sollen oder auch der *State* der **QMLUI** geändert
werden soll.
"""
# Eine Liste aller Mitglieder in der Datenbank wird erstellt
try:
sql_anweisung = sql_anweisungen.sql(tabelle="tblMitglied")
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0],
name=eintrag[1], vorname=eintrag[2],
sozialnummer=eintrag[3], bday=eintrag[4],
mobiltelefon=eintrag[5], email=eintrag[6],
telefonnummer=eintrag[7], ortschaft=eintrag[8],
adresse=eintrag[9], postleitzahl=eintrag[10],
lehrgangsstunden=eintrag[11], apteinsatz=eintrag[12],
aptatemschutz=eintrag[13], mediKontrolle=eintrag[14]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('mitglieder_liste', datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('mitglieder_liste', None)
# Liste aller Lehrgänge wird erstellt
try:
sql_anweisung = sql_anweisungen.sql(tabelle='tblLehrgang')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(lehrgang_objekt.Lehrgang(
schlussel=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('alle_lehrgaenge', datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('alle_lehrgaenge', None)
# Liste aller Auszeichnungen wird erstellt
try:
sql_anweisung = sql_anweisungen.sql(tabelle='tblAuszeichnung')
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
datensatz = []
for eintrag in sql_resultate:
datensatz.append(auszeichnung_objekt.Auszeichnung(
auszeichnung=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('alle_auszeichnungen', datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('alle_auszeichnungen', None)
# Liste aller Führerscheine wird erstellt
try:
fuehrerscheine = ['A', 'B', 'C', 'D', 'E']
datensatz = []
for eintrag in fuehrerscheine:
datensatz.append(fuhrerschein_objekt.Fuhrerschein(
schlussel=eintrag))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('alle_fuhrerscheine', datenliste)
except:
# Wenn eine Ausnahme eintritt, leere Liste setzen
self.kontext.setContextProperty('alle_auszeichnungen', None)
if state_wechseln:
self.kommandant_bereich_aufbau_signal.emit()
def protokoll_verwaltung(self, state_wechseln=True):
""" *Das Menü zur Protokollverwaltung wird aufgebaut*
**Beschreibung**
Das Menü zur Verwaltung der Protokolle wird aufgebaut. Die Hauptauswahl
für Protokolle wird aufgebaut und Listen von
- Fahrzeugen
- Mitglieder
- Inventargegenstände
- Ereignisse
werden aufgebaut, welche in *AuswahlListen* (ComboBox) gesetzt werden,
mit welchen Referenzen gesetzt werden können.
**Parameter**
- state_wechseln: *Boolean* Angabe ob nur die einzelnen Listen neu
erstellt werden sollen oder auch der *State* der **QMLUI** geändert
werden soll.
"""
# Hilfsvariable um herauszufinden ob ein Fehler aufgetreten ist
fehler = False
# Eine Liste aller Protokolle wird erstellt zur Hauptauswahl
sql_anweisung = sql_anweisungen.sql(tabelle="tblProtokolle")
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('protokoll_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(protokoll_objekt.Protokoll(
schlussel=eintrag[0],
bezeichnung=eintrag[1], datum=eintrag[2],
inhalt=eintrag[3]))
except:
datensatz.append(protokoll_objekt.Protokoll(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
# Kontrollieren ob nicht vorher ein Fehler aufgetreten war
if not fehler:
self.kontext.setContextProperty('protokoll_liste', datenliste)
else:
fehler = False
# Eine Liste aller Ereignisse zum setzen als Referenzen wird erstellt
sql_resultate = None
sql_anweisung = sql_anweisungen.sql(tabelle="tblEreignis")
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('ereignis_liste',
'Keine Ereignisse')
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(ereignis_objekt.Ereignis(
schlussel=eintrag[0], typ=eintrag[1],
startdatum=eintrag[2], startzeit=eintrag[3],
enddatum=eintrag[4], endzeit=eintrag[5],
bezeichnung=eintrag[6]))
except:
datensatz.append(ereignis_objekt.Ereignis(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
# Kontrollieren ob nicht vorher ein Fehler aufgetreten war
if not fehler:
self.kontext.setContextProperty('ereignis_liste', datenliste)
else:
fehler = False
# Eine Liste aller Inventargegenstände zum setzen als Refernzen wird
# erstellt
sql_anweisung = sql_anweisungen.sql(
select="idInventarnummer, dtBezeichnung, dtKategorie, dtKnappheit",
tabelle="tblInventar")
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('inventar_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[2], knappheit=eintrag[3]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
# Kontrollieren ob nicht vorher ein Fehler aufgetreten war
if not fehler:
self.kontext.setContextProperty('inventar_liste', datenliste)
else:
fehler = False
# Eine Liste aller Mitglieder zum setzen als Referenzen wird erstellt
sql_anweisung = sql_anweisungen.sql(
tabelle="tblMitglied",
select="idStammlistennummer, dtName, dtVorname")
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('mitglied_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0],
name=eintrag[1], vorname=eintrag[2]))
except:
datensatz.append(mitglied_objekt.Mitglied(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
# Kontrollieren ob nicht vorher ein Fehler aufgetreten war
if not fehler:
self.kontext.setContextProperty('mitglied_liste', datenliste)
else:
fehler = False
# Eine Liste aller Fahrzeuge zum setzen als Referenzen wird erstellt
sql_anweisung = sql_anweisungen.sql(tabelle='tblFahrzeug')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('fahrzeug_liste', None)
fehler = True
datensatz = []
# Instanz Variablen für Fahrzeug() und FahrzeugTyp() werden gesetzt
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(fahrzeug_objekt.Fahrzeug(
schlussel=eintrag[0],
kennzeichen=eintrag[1], bezeichnung=eintrag[2],
besatzung=eintrag[3], technisches_problem=eintrag[4],
kommentar=eintrag[5], tuv=eintrag[6],
werkstatt=eintrag[7], typ=eintrag[8]))
except:
datensatz.append(fahrzeug_objekt.Fahrzeug(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
# Kontrollieren ob nicht vorher ein Fehler aufgetreten war
if not fehler:
self.kontext.setContextProperty('fahrzeug_liste', datenliste)
if state_wechseln:
self.protokoll_verwaltung_signal.emit()
def kleider_verwaltung(self):
""" *Die Verwaltung der Kleider wird aufgerufen* """
# Alle Kleider werden aufgelistet
sql_anweisung = sql_anweisungen.sql(tabelle='tblInventar',
select='*',
filtern='dtKategorie="Kleider"')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('kleider_auflistung', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
groesse=eintrag[2], zustand=eintrag[3],
kategorie=eintrag[4], knappheit=eintrag[6],
mitglied=eintrag[7]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('kleider_auflistung',
datenliste)
else:
self.kontext.setContextProperty('kleider_auflistung', None)
# Kategorien für die Kleider werden aufgelistet
sql_anweisung = sql_anweisungen.sql(tabelle='tblInventar',
select='DISTINCT(dtBezeichnung)',
filtern='dtKategorie="Kleider"')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('kleider_gruppierung', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Kleidung(
art=eintrag[0]))
except:
datensatz.append(inventarliste_objekt.Kleidung(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('kleider_gruppierung',
datenliste)
else:
self.kontext.setContextProperty('kleider_gruppierung', None)
# Auflistung aller Mitglieder
sql_anweisung = sql_anweisungen.sql(tabelle='tblMitglied', select='*')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('kleider_mitglieder', None)
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0], name=eintrag[1],
vorname=eintrag[2]))
except:
datensatz.append(mitglied_objekt.Mitglied(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('kleider_mitglieder',
datenliste)
else:
self.kontext.setContextProperty('kleider_mitglieder', None)
self.kleider_gegenstaende_setzen_signal.emit()
def ereignis_verwaltung(self, einsatz=False):
""" *Das Menü zur Vewaltung von Ereignissen wird aufgerufen*
**Parameter**
- einsatz: Wenn *einsatz* gesetzt ist, werden nur Ereignisse welche als
Einsatz markiert wurden angezeigt
"""
# Hilfsvariable um herauszufinden ob ein Fehler aufgetreten ist
fehler = False
# Ereignis Typen
ereignis_typen = ['Fest', 'Lehrgang', 'Medizinische Kontrolle',
'Einsatz', 'Generalversammlung', 'Übung',
'Sonstiges']
datensatz = []
for eintrag in ereignis_typen:
datensatz.append(ereignis_objekt.EreignisTyp(
typ=eintrag))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('ereignis_typen', datenliste)
# Einsatz Typen
einsatz_typen = ['Feuer', 'Verkehrssunfall', 'Technischer Einsatz']
datensatz = []
for eintrag in einsatz_typen:
datensatz.append(ereignis_objekt.EreignisTyp(
typ=eintrag))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('einsatz_typen', datenliste)
# Liste aller Mitglieder
sql_anweisung = sql_anweisungen.sql(
tabelle='tblMitglied',
select='idStammlistennummer, dtName, dtVorname')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('mitglied_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0], name=eintrag[1], vorname=eintrag[2]))
except:
datensatz.append(mitglied_objekt.Mitglied(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
if not fehler:
self.kontext.setContextProperty('mitglied_liste', datenliste)
# Falls es sich um einen Einsatzbericht handelt
if einsatz:
# Liste aller Einsätze
sql_anweisung = sql_anweisungen.sql(
tabelle='tblEreignis',
filtern='dtEreignisTyp="Einsatz"')
else:
# Liste aller Ereignisse
sql_anweisung = sql_anweisungen.sql(tabelle='tblEreignis')
try:
fehler = False
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('ereignis_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(ereignis_objekt.Ereignis(
schlussel=eintrag[0],
typ=eintrag[1], startdatum=eintrag[2],
startzeit=eintrag[3], enddatum=eintrag[4],
endzeit=eintrag[5], bezeichnung=eintrag[6]))
except:
datensatz.append(ereignis_objekt.Ereignis(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('ereignis_liste', datenliste)
else:
self.kontext.setContextProperty('ereignis_liste', None)
# Kontrolle in welchem Menü sich der Benutzer befindet
if einsatz:
self.einsatz_verwaltung_signal.emit()
else:
self.ereignis_verwaltung_signal.emit()
def atemschutz_liste_setzen(self, status=''):
""" *Die Verwaltung zum Atemschutz wird aufgebaut*
**Parameter**
- status: Gibt an ob die Liste nach beschädigten Geräten gefiltert
werden soll oder nicht
"""
if status == "checked":
beschaedigt_filter = True
else:
beschaedigt_filter = False
if beschaedigt_filter:
# SQL Anweisung zum Anzeigen von nur beschädigten Atemschutzgeräten
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
filtern='dtKategorie="Atemschutz" AND dtzustand="beschädigt"',
select='*',
sortieren='dtBezeichnung')
else:
# SQL Anweisung für alle Atemschutzgeräte
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
filtern='dtKategorie="Atemschutz"', select='*',
sortieren='dtBezeichnung')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
kontrolle=eintrag[5], knappheit=eintrag[6],
mitglied=eintrag[7]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('atemschutz_auflistung',
datenliste)
else:
self.kontext.setContextProperty('atemschutz_auflistung', None)
sql_anweisung = sql_anweisungen.sql(tabelle='tblInventar',
filtern='dtKategorie="Atemschutz"',
select='*',
sortieren='dtKontrollDatum')
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
kontrolle=eintrag[5], knappheit=eintrag[6],
mitglied=eintrag[7], kontrolle_anzeigen=True))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.atemschutz_kontrolle_liste = datensatz
self.kontext.setContextProperty('atemschutz_kontrolle_liste_model',
datenliste)
else:
self.atemschutz_kontrolle_liste = None
self.kontext.setContextProperty('atemschutz_kontrolle_liste_model',
None)
self.atemschutz_liste_setzen_signal.emit()
def schlauch_filter(self):
""" *Filtern der Schlauch Liste*
**Beschreibung**
Abhängig davon welche **JaNeinAuswahl** ausgewählt sind:
- chkTypA
- chkTypB
- chkTypC
- chkTypD
- chkZustand,
wird die Liste der verschiedenen Schläuche nach dieser Auswahl
gefiltert.
"""
filtern_nach = ""
if self.typAStatus == "checked":
filtern_nach = filtern_nach + "'A Schlauch'"
if self.typBStatus == "checked":
if filtern_nach:
filtern_nach = filtern_nach + ", 'B Schlauch'"
else:
filtern_nach = filtern_nach + "'B Schlauch'"
if self.typCStatus == "checked":
if filtern_nach:
filtern_nach = filtern_nach + ", 'C Schlauch'"
else:
filtern_nach = filtern_nach + "'C Schlauch'"
if self.typDStatus == "checked":
if filtern_nach:
filtern_nach = filtern_nach + ", 'D Schlauch'"
else:
filtern_nach = filtern_nach + "'D Schlauch'"
if self.zustandStatus == "checked" and filtern_nach == '':
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='*',
filtern='dtZustand="beschädigt" AND dtKategorie="Schlauche"',
sortieren='dtBezeichnung')
elif self.zustandStatus == "checked":
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='*',
filtern='dtZustand="beschädigt" AND dtBezeichnung IN(%s)' %
(filtern_nach),
sortieren='dtBezeichnung')
else:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
select='*',
filtern='dtBezeichnung IN(%s)' % (filtern_nach),
sortieren='dtBezeichnung')
try:
if filtern_nach == "" and self.zustandStatus == "unchecked":
self.schlauch_gegenstaende_liste()
return
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
zustand=eintrag[3], kategorie=eintrag[4],
knappheit=eintrag[6]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
schlauche = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('schlauch_gegenstaende', schlauche)
else:
self.kontext.setContextProperty('schlauch_gegenstaende', None)
self.aktuelle_schlauch_liste = datensatz
self.schlauch_liste_setzen_signal.emit()
def protokoll_bericht(self):
""" *Ein Bericht des aktuellen Protokolls wird erstellt*
**Beschreibung**
Ein Bericht wird aus dem aktuellen Protokoll erstellt. Als erstes wird
der eigentliche Inhalt des Protokolls erstellt und anschließend wird
die Liste aller Referenzen ausgelesen und die Informationen der
Referenzen werden gesetzt.
"""
# Hauptinformationen setzen
bezeichnung = self.protokoll.datensatz.bezeichnung
datum = self.protokoll.datensatz.datum
inhalt = self.protokoll.datensatz.inhalt
bericht = ""
bericht = bericht + '<p class="bericht">\n'
bericht = bericht + '<h2>Protokoll Bericht vom %s</h2>\n' % datum
bericht = bericht + '<h3>Bezeichnung: %s</h3>' % bezeichnung
bericht = bericht + '<h3>Inhalt</h3><br />'
bericht = bericht + inhalt
bericht = bericht + '<h3>Gesetzte Referenzen</h3>'
# Inventar Referenzen setzen
bericht = bericht + '<h4>Inventargegenstände</h4>'
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar_Protokoll_Referenzen',
select='fiInventarnummerProtokoll',
filtern='fiProtokollInventar=%s' % self.schlussel
)
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
if sql_resultate:
for schlussel in sql_resultate:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblInventar',
filtern='idInventarnummer=%s' % str(schlussel[0]))
try:
inventar_info = self.datenbank_verbindung.execute(
sql_anweisung)
except:
pass
for inhalt in inventar_info:
if inhalt[1]:
bericht = bericht + '<b>Bezeichnung</b>: '
bericht = bericht + inhalt[1] + '<br />'
if inhalt[2]:
bericht = bericht + '<b>Größe</b>: '
bericht = bericht + inhalt[2] + '<br />'
if inhalt[3]:
bericht = bericht + '<b>Zustand</b>: '
bericht = bericht + inhalt[3] + '<br />'
if inhalt[4]:
bericht = bericht + '<b>Kategorie</b>: '
bericht = bericht + inhalt[4] + '<br />'
if inhalt[5]:
datum = inhalt[5]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>Letzte Kontrolle</b>: ' + str(
datum) + '<br />'
bericht = bericht + '<br />'
else:
bericht = bericht + '<i>Keine Inventargegenstände Referenzen</i>'
# Ereignis Referenzen setzen
sql_resultate = None # keine Resultate von vorher
bericht = bericht + '<h4>Ereignisse</h4>'
sql_anweisung = sql_anweisungen.sql(
tabelle='tblEreignis_Protokoll_Referenzen',
select='fiEreignisnummerProtokoll',
filtern='fiProtokoll=%s' % self.schlussel)
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
if sql_resultate:
for schlussel in sql_resultate:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblEreignis',
filtern='idEreignisnummer=%s' % str(schlussel[0]))
try:
ereignis_info = self.datenbank_verbindung.execute(
sql_anweisung)
except:
pass
for inhalt in ereignis_info:
if inhalt[6]:
bericht = bericht + '<b>Bezeichnung</b>: '
bericht = bericht + inhalt[6] + '<br />'
if inhalt[1]:
bericht = bericht + '<b>Ereignis</b>: '
bericht = bericht + inhalt[1] + '<br />'
if inhalt[2]:
datum = inhalt[2]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>Start Datum</b>: ' + str(
datum) + '<br />'
if inhalt[3]:
bericht = bericht + '<b>Start Zeit</b>: ' + str(
inhalt[3]) + '<br />'
if inhalt[4]:
datum = inhalt[4]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>End Datum</b>: ' + str(
datum) + '<br />'
if inhalt[5]:
bericht = bericht + '<b>End Zeit</b>: ' + str(
inhalt[5]) + '<br />'
bericht = bericht + '<br />'
else:
bericht = bericht + '<i>Keine Ereignis Referenzen</i>'
# Mitglied Referenzen setzen
sql_resultate = None
bericht = bericht + '<h4>Mitglieder</h4>'
sql_anweisung = sql_anweisungen.sql(
tabelle='tblMitglied_Protokoll_Referenzen',
select='fiStammlistennummerProtokoll',
filtern='fiProtokollMitglied=%s' % self.schlussel)
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
if sql_resultate:
for schlussel in sql_resultate:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblMitglied',
filtern='idStammlistennummer=%s' % str(schlussel[0]))
try:
mitglied_info = self.datenbank_verbindung.execute(
sql_anweisung)
except:
pass
for inhalt in mitglied_info:
if inhalt[1]:
bericht = bericht + '<b>Name</b>: '
bericht = bericht + inhalt[1] + '<br />'
if inhalt[2]:
bericht = bericht + '<b>Vorname</b>: '
bericht = bericht + inhalt[2] + '<br />'
if inhalt[3]:
bericht = bericht + '<b>SozialversicherungNr</b>: '
bericht = bericht + str(inhalt[3]) + '<br />'
if inhalt[4]:
datum = inhalt[4]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>Geburtsdatum</b>: ' + str(
datum) + '<br />'
if inhalt[5]:
bericht = bericht + '<b>Mobiltelefon</b>: ' + str(
inhalt[5]) + '<br />'
if inhalt[6]:
bericht = bericht + '<b>Email</b>: '
bericht = bericht + inhalt[6] + '<br />'
if inhalt[7]:
bericht = bericht + '<b>Telefonnummer</b>: ' + str(
inhalt[7]) + '<br />'
if inhalt[8]:
bericht = bericht + '<b>Ortschaft</b>: '
bericht = bericht + inhalt[8] + '<br />'
if inhalt[9]:
bericht = bericht + '<b>Adresse</b>: '
bericht = bericht + inhalt[9] + '<br />'
if inhalt[10]:
bericht = bericht + '<b>Postleitzahl</b>: ' + str(
inhalt[10]) + '<br />'
if inhalt[11]:
bericht = bericht + '<b>Lehrgangsstunden</b>: ' + str(
inhalt[11]) + '<br />'
if inhalt[12]:
if inhalt[12] == 0:
bericht = bericht + '<b>APTEinsatz</b>: NEIN<br />'
else:
bericht = bericht + '<b>APTEinsatz</b>: JA<br/>'
if inhalt[13]:
if inhalt[13] == 0:
bericht = bericht + '<b>APTAtemschutz</b>: JA<br />'
else:
bericht = bericht+'<b>APTAtemschutz</b>: NEIN<br />'
if inhalt[14]:
datum = inhalt[4]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>Med. Kontrolle</b>: ' + str(
datum) + '<br />'
bericht = bericht + '<br />'
else:
bericht = bericht + '<i>Keine Mitglieder Referenzen</i>'
# Fahrzeug Referenz setzen
sql_resultate = None
bericht = bericht + '<h4>Fahrzeuge</h4>'
sql_anweisung = sql_anweisungen.sql(
tabelle='tblFahrzeug_Protokoll_Referenzen',
select='fiFahrzeugNummerProtokoll',
filtern='fiProtokollFahrzeug=%s' % self.schlussel)
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
pass
if sql_resultate:
for schlussel in sql_resultate:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblFahrzeug',
filtern='idFahrzeugNummer=%s' % str(schlussel[0]))
try:
fahrzeug_info = self.datenbank_verbindung.execute(
sql_anweisung)
except:
pass
for inhalt in fahrzeug_info:
if inhalt[1]:
bericht = bericht + '<b>Kennzeichen</b>: '
bericht = bericht + inhalt[1] + '<br />'
if inhalt[2]:
bericht = bericht + '<b>Bezeichnung</b>: '
bericht = bericht + inhalt[2] + '<br />'
if inhalt[3]:
bericht = bericht + '<b>Max. Besatzung</b>: ' + str(
inhalt[3]) + '<br />'
if inhalt[4]:
if inhalt[4] == 0:
bericht = bericht+'<b>Techn. Problem</b>: NEIN<br/>'
else:
bericht = bericht+'<b>Techn. Problem</b>: JA<br />'
if inhalt[5]:
bericht = bericht + '<b>Techn. Kommentar</b>'
bericht = bericht + inhalt[5] + '<br />'
if inhalt[6]:
datum = inhalt[6]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht + '<b>TÜV Kontrolle</b>: ' + str(
datum) + '<br />'
if inhalt[7]:
datum = inhalt[7]
try:
datum = datum.strftime("%d-%m-%Y")
except ValueError:
pass
bericht = bericht+'<b>Werkstatt Kontrolle</b>: ' + str(
datum) + '<br />'
if inhalt[8]:
bericht = bericht + '<b>Typ</b>: '
bericht = bericht + inhalt[8] + '<br/>'
bericht = bericht + '<br />'
else:
bericht = bericht + '<i>Keine Fahrzeug Referenzen</i>'
# Der Bericht wird erstellt
bericht_erstellung.html_bericht(daten=bericht, benutzer='Sekretär',
datei_name=bezeichnung)
def ereignisInfo(self, packung, einsatz=False):
""" *Die Informationen eines Ereignisses werden gesetzt*
**Parameter**
- packung: Verpackter Datensatz eines Ereignisses
- einsatz: Wenn *einsatz* auf True steht, werden weitere Informationen
eines Einsatzes ausgelesen
"""
# Hilfsvariable um herauszufinden ob ein Fehler aufgetreten ist
fehler = False
self.packung = packung
self.ereignisSchlussel = packung.datensatz.schlussel
self.kontext.setContextProperty('ereignis_bezeichnung',
packung.datensatz.bezeichnung)
self.kontext.setContextProperty('ereignis_typ_t',
packung.datensatz.typ)
self.kontext.setContextProperty('ereignis_startdatum',
str(packung.datensatz.startdatum))
self.kontext.setContextProperty('ereignis_startzeit',
str(packung.datensatz.startzeit))
self.kontext.setContextProperty('ereignis_enddatum',
str(packung.datensatz.enddatum))
self.kontext.setContextProperty('ereignis_endzeit',
str(packung.datensatz.endzeit))
# Liste aller Mitglieder welche an einem Ereignis teilgenommen haben
sql_anweisung = sql_anweisungen.sql(
tabelle='tblTeilgenommen, tblMitglied',
select="idStammlistennummer, dtName, dtVorname",
filtern="fiStammlistennummerTeilnahme=idStammlistennummer AND "
"fiEreignisnummer=%s" % (self.ereignisSchlussel))
try:
sql_resultate = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('teilnahme_liste', None)
fehler = True
datensatz = []
if sql_resultate:
for eintrag in sql_resultate:
try:
datensatz.append(mitglied_objekt.Mitglied(
schlussel=eintrag[0],
name=eintrag[1], vorname=eintrag[2]))
except:
datensatz.append(mitglied_objekt.Mitglied(None))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('teilnahme_liste', datenliste)
else:
self.kontext.setContextProperty('teilnahme_liste', None)
if einsatz:
sql_anweisung = sql_anweisungen.sql(
tabelle='tblEinsatzbericht',
select='*', filtern='fiEreignisnummerEinsatz=%s' % (
self.ereignisSchlussel))
try:
fehler = False
eintrag = self.datenbank_verbindung.execute(sql_anweisung)
except:
self.kontext.setContextProperty('einsatz_einsatztyp', None)
self.kontext.setContextProperty('einsatz_ortschaft', None)
self.kontext.setContextProperty('einsatz_adresse', None)
self.kontext.setContextProperty('einsatz_postleitzahl', None)
self.kontext.setContextProperty('betreff_name', None)
self.kontext.setContextProperty('betreff_vorname', None)
self.einsatzInfo_signal.emit()
fehler = True
if not fehler:
self.kontext.setContextProperty('einsatz_einsatztyp',
eintrag[0][1])
self.kontext.setContextProperty('einsatz_ortschaft',
eintrag[0][2])
self.kontext.setContextProperty('einsatz_adresse',
eintrag[0][3])
self.kontext.setContextProperty('einsatz_postleitzahl',
eintrag[0][4])
self.kontext.setContextProperty('betreff_name',
eintrag[0][5])
self.kontext.setContextProperty('betreff_vorname',
eintrag[0][6])
self.einsatzInfo_signal.emit()
self.ereignisInfo_signal.emit()