def auswahl_listen_aufbauen(self):
""" *Die verschiedenen AuswahlListe Komponenten aufbauen* """
groessen_liste = ['L', 'S', 'XL', 'XXL']
zustand_liste = ['Beschädigt', 'Schlecht', 'Mittel', 'Gut']
kategorie_liste = ['Schlauche', 'Atemschutz', 'Kommunikation',
'Kleider', 'Schaummittel', 'Maschinerie',
'1. Hilfe']
datensatz_groessen = []
datensatz_zustand = []
datensatz_kategorie = []
for eintrag in groessen_liste:
datensatz_groessen.append(inventarliste_objekt.Groesse(
groesse=eintrag))
for eintrag in zustand_liste:
datensatz_zustand.append(inventarliste_objekt.Zustand(
zustand=eintrag))
for eintrag in kategorie_liste:
datensatz_kategorie.append(inventarliste_objekt.Kategorie(
kategorie=eintrag))
groessen = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz_groessen)
zustaende = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz_zustand)
kategorien = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz_kategorie)
self.kontext.setContextProperty('groessen_auswahl', groessen)
self.kontext.setContextProperty('zustaende_auswahl', zustaende)
self.kontext.setContextProperty('kategorien_auswahl', kategorien)
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 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 protokoll_info_setzen(self, protokoll):
""" *Die Daten des ausgewählten Protokolls werden gesetzt*
**Beschreibung**
Die Informationen eines Protokolls werden gesetzt und der gesamte
**Datensatz** des jeweiligen Protokolls wird in eine Klassenvariable
gespeichert, zur späteren weiter verwendung.
**Parameter**
- protokoll: Der **datensatz** des in der Liste ausgewählten Protokolls
"""
self.protokoll = protokoll
self.schlussel = protokoll.datensatz.schlussel
datum = protokoll.datensatz.datum
bezeichnung = protokoll.datensatz.bezeichnung
try:
referenzen = protokoll_logik.referenzenListe(
self.datenbank_verbindung, self.schlussel)
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
referenzen)
self.kontext.setContextProperty('protokoll_referenzen', datenliste)
except:
self.kontext.setContextProperty('protokoll_referenzen', None)
inhalt = protokoll.datensatz.inhalt
self.kontext.setContextProperty('protokoll_datum', str(datum))
self.kontext.setContextProperty('protokoll_inhalt', inhalt)
self.kontext.setContextProperty('protokoll_bezeichnung_info',
bezeichnung)
self.protokoll_info_setzen_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 schlauch_typ_auswahliste_aufbauen(self):
""" *AuswahlListe von Schlauch Typs wird aufgebaut* """
schlauch_typ_liste = ['A Schlauch', 'B Schlauch', 'C Schlauch',
'D Schlauch']
datensatz = []
for eintrag in schlauch_typ_liste:
datensatz.append(schlauche_objekt.SchlauchTypListe(
typ=eintrag))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('schlauch_typ_liste', datenliste)
def admin_bereich_aufbau(self):
""" *Der Admin Bereich wird aufgebaut*
**Beschreibung**
Eine Liste mit allen Tabellen in der Datenbank wird erstellt.
"""
tabellen_liste = self.datenbank_verbindung.liste_aller_tabellen()
datensatz = []
for eintrag in tabellen_liste:
datensatz.append(db_tabellen_objekt.DBTabelle(tabelle=eintrag[0]))
datenliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('tabellen_liste', datenliste)
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 ausstattung_verwaltung_aufrufen(self):
""" *Die Verwaltung der Fahrzeugausstattung wird aufgerufen* """
self.ausstattung_anzeigenVerstecken()
datensatz = []
# Wird benötigt damit die Datenbank eine neue Anfrage durchführt und
# nicht aus dem Cache liest
self.datenbank_verbindung.commit()
liste = inventar.nicht_verwendete_inventargegenstaende(
self.datenbank_verbindung)
if liste:
for eintrag in liste:
try:
datensatz.append(inventarliste_objekt.Inventarliste(
schlussel=eintrag[0], bezeichnung=eintrag[1],
kategorie=eintrag[4], knappheit=eintrag[6],
anzahl=eintrag[8]))
except:
datensatz.append(inventarliste_objekt.Inventarliste(None))
inventarliste = verpacken_modelisieren.list_verpackung_modelisieren(
datensatz)
self.kontext.setContextProperty('inventarliste', inventarliste)
else:
self.kontext.setContextProperty('inventarliste', None)
self.ausstattung_verwaltung_starten_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 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 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 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 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()
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()
