Esempio n. 1
0
 def einstellungen_laden(self):
     """ *Die Einstellungen werden aus der konfig.cfg Datei ausgelesen* """
     einstellungen = konfig.laden_konfig()
     try:
         self.kontext.setContextProperty('db_adresse', einstellungen[0])
         self.kontext.setContextProperty('db_port', einstellungen[1])
         self.kontext.setContextProperty('db_name', einstellungen[2])
         self.kontext.setContextProperty('db_benutzer', einstellungen[3])
         self.kontext.setContextProperty('db_passwort', einstellungen[4])
         return einstellungen
     except:
         pass
Esempio n. 2
0
    def __init__(self):
        super(QMLUI, self).__init__()
        adminDB = admin_db_verbindung
        # Verbindung zur Datenbank aufbauen
        try:
            einstellungen = konfig.laden_konfig()
            self.datenbank_verbindung = adminDB.Admin_DB_Verbindung(
                einstellungen)
        except:
            print("Es konnte keine Datenbankverbindung hergestellt werden")

        # Festlegung welche Funktionen von welchen Buttons aufgerufen werden
        button_komponenten_funktionen = {
            "btnTabelleKontrolle": self.tabelle_kontrollieren,
            "btnTabelleOptimieren": self.tabelle_optimieren,
            "btnTabelleReparieren": self.tabelle_reparieren
        }

        # Festlegung welche Funktionen von welchen Listen aufgerufen werden
        listen_komponenten_funktionen = {
            "lstTabellen": [True, self.tabellen_name_setzen]
        }

        # Kontroller für die QMLUI werden eingerichtet
        button_kontroller = button.Kontroller(self,
                                              button_komponenten_funktionen)
        listen_kontroller = listen.Kontroller(self,
                                              listen_komponenten_funktionen)

        # Attribute/Kontroller auf welche die QMLUI zugreifen kann
        self.kontext = self.rootContext()
        self.kontext.setContextProperty('button_kontroller', button_kontroller)
        self.kontext.setContextProperty('listen_kontroller', listen_kontroller)

        # Aufrufen der Startmethoden
        self.admin_bereich_aufbau()

        # QMLUI wird geladen
        self.setWindowTitle("FVS - Admin")
        self.setWindowIcon(QIcon("./icon.png"))
        self.setSource(QtCore.QUrl.fromLocalFile(
            './QMLUI/Admin.qml'))
        self.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView)

        # QMLUI Attribute werden Python zugänglich gemacht
        self.ui_objekt = self.rootObject()

        # Slots der QMLUI
        self.tabelle_kontrollieren_signal.connect(
            self.ui_objekt.tabelle_kontrollieren_qml)
Esempio n. 3
0
    def __init__(self):
        super(QMLUI, self).__init__()

        # Verbindung zur Datenbank aufbauen
        try:
            einstellungen = konfig.laden_konfig()
            self.datenbank_verbindung = db_verbindung.DB_Verbindung(
                einstellungen)
        except:
            print("Es konnte keine Datenbankverbindung hergestellt werden")
            # Weiteres QMLUI Fenster erstellen und UI_Aufbau Datei erstellen,
            # importieren und aufrufen und als MessageBox verwenden

        # Festlegung welche Funktionen von welchen Listen aufgerufen werden
        listen_komponenten_funktionen = {
            "lstMitglieder": [True, self.mitglied_info_setzen],
            "lstLehrgaenge": [True, self.lehrgaenge_schlussel_setzen],
            "lstAuszeichnungen": [True, self.auszeichnungen_schlussel_setzen],
            "lstFuhrerscheine": [True, self.fuhrerscheine_schlussel_setzen],
            "cmbLehrgaengeAuswahl": [True, self.lehrgang_auswahl_setzen],
            "cmbAuszeichnungAuswahl": [True, self.auszeichnung_auswahl_setzen],
            "cmbFuhrerscheinAuswahl": [True, self.fuhrerschein_auswahl_setzen],
            "lstInventar": [True, self.inventar_schlussel_setzen],
            "lstAusrustung": [True, self.ausrustung_schlussel_setzen]
        }

        # Festlegung welche Funktionen von welchen Buttons aufgerufen werden
        button_komponenten_funktionen = {
            "btnSekretaerBereich": self.sekretaer_bereich_aufrufen,
            "btnInventarBereich": self.inventarist_bereich_aufrufen,
            "btnMaschinistBereich": self.maschinist_bereich_aufrufen,
            "btnLehrgangHinzu": self.lehrgang_hinzu,
            "btnLehrgangEntfernen": self.lehrgang_entfernen,
            "btnAuszeichnungHinzu": self.auszeichnung_hinzu,
            "btnAuszeichnungEntfernen": self.auszeichnung_entfernen,
            "btnFuhrerscheinHinzu": self.fuhrerschein_hinzu,
            "btnFuhrerscheinEntfernen": self.fuhrerschein_entfernen,
            "btnNeuMitglied": self.neues_mitglied,
            "btnEntfernenMitglied": self.entfernen_mitglied,
            "btnAktualisieren": self.mitglied_aktualisieren,
            "btnAusrustungBearbeiten": self.ausrustung_bearbeiten,
            "btnZuruckMitglied": self.mitglied_info_anzeigen,
            "btnAusrustungHinzu": self.ausrustung_hinzu,
            "btnAusrustungEntfernen": self.ausrustung_entfernen,
            "btnOverlayBericht": self.overlay_bericht
        }

        # Festlegung welche Funktionen von welchen Operationssignalen
        # werden sollen aufgerufen
        operationen_funktionen = {
            "mitglied_variablen_gesetzt": self.mitglied_info_in_db_speichern
        }

        # Kontroller für die QMLUI werden eingerichtet
        listen_kontroller = listen.Kontroller(self,
                                              listen_komponenten_funktionen)
        button_kontroller = button.Kontroller(self,
                                              button_komponenten_funktionen)
        operationen_kontroller = operationen.Kontroller(self,
                                                        operationen_funktionen)

        # Attribute/Kontroller auf welche die QMLUI zugreifen kann
        self.kontext = self.rootContext()
        self.kontext.setContextProperty('listen_kontroller', listen_kontroller)
        self.kontext.setContextProperty('button_kontroller', button_kontroller)
        self.kontext.setContextProperty('operationen_kontroller',
                                        operationen_kontroller)

        # Aufrufen der Startmethoden
        self.overlay_meldungen_aufbau()
        self.kommandant_bereich_aufbau()

        # QMLUI wird geladen
        self.setWindowTitle("FVS - Kommandant")
        self.setWindowIcon(QIcon("./icon.png"))
        self.setSource(QtCore.QUrl.fromLocalFile(
            './QMLUI/Kommandant.qml'))
        self.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView)

        # QMLUI Attribute werden Python zugänglich gemacht
        self.ui_objekt = self.rootObject()

        # Slots der QMLUI
        self.kommandant_bereich_aufbau_signal.connect(
            self.ui_objekt.kommandant_bereich_aufbau_qml)

        self.mitglied_info_setzen_signal.connect(
            self.ui_objekt.mitglied_info_setzen_qml)

        self.mitglied_info_abspeichern_signal.connect(
            self.ui_objekt.mitglied_info_abspeichern_qml)

        self.ausrustung_bearbeiten_signal.connect(
            self.ui_objekt.ausrustung_bearbeiten_qml)
Esempio n. 4
0
    def __init__(self):
        super(QMLUI, self).__init__()
        # Verbindung zur Datenbank wird aufgebaut
        try:
            einstellungen = konfig.laden_konfig()
            self.datenbank_verbindung = db_verbindung.DB_Verbindung(
                einstellungen)
        except:
            print("Es konnte keine Datenbankverbindung hergestellt werden")

        listen_komponenten_funktionen = {
            "lstSonstigeGegenstaende": [True,
                                        self.sonstige_informationen_setzen],

            "lstSchlauchGegenstaende": [True,
                                        self.aktueller_schlauch_info_setzen],

            "lstAtemschutzAuflistung": [True, self.atemschutz_info_setzen],
            "lstKleiderAuflistung": [True, self.kleider_info_setzen],

            "lstKommunikationAuflistung": [True,
                                           self.kommunikation_info_setzen]
        }

        button_komponenten_funktionen = {
            "btnSonstigeVerwaltung": self.sonstige_gegenstaende_liste,

            "btnZumHauptmenu": self.zum_hauptmenu,

            "btnSchlauchVerwaltung": self.schlauch_gegenstaende_liste,

            "btnSchlauchBericht": self.schlauch_bericht_erstellen,

            "btnEinzelnSchlauchEntfernen": self.einzeln_schlauch_entfernen,

            "btnAktuelleSchlauchListeEntfernen":
            self.aktuel_schlauch_liste_entf,

            "btnSchlaucheHinzufugen": self.neu_schlauch_anzahl_abfragen,

            "btnAtemschutzVerwaltung": self.atemschutz_liste_setzen,

            "btnAtemschutzKontrollenBericht":
            self.atemschutz_kontrolle_bericht,

            "btnAtemschutzBeschaedigtBericht":
            self.atemschutz_beschaedigt_bericht,

            "btnNeuAtemschutz": self.neu_atemschutz,

            "btnEntfernenAtemschutz": self.atemschutz_entfernen,

            "btnAktualisierenAtemschutz": self.atemschutz_aktualisieren,

            "btnKleiderVerwaltung": self.kleider_verwaltung,

            "btnKleiderNeu": self.kleider_neu,

            "btnKleiderEntfernen": self.kleider_entfernen,

            "btnKleiderAktualisieren": self.kleider_aktualisieren,

            "btnKommunikationVerwaltung": self.kommunikation_verwaltung,

            "btnKommunikationNeu": self.kommunikation_neu,

            "btnKommunikationEntfernen": self.kommunikation_entfernen,

            "btnKommunikationAktualisieren": self.kommunikation_aktualisieren,
            "btnNeuSonstiges": self.sonstiges_neu,
            "btnEntfernenSonstiges": self.sonstiges_entfernen,
            "btnAbspeichernSonstiges": self.sonstiges_abspeichern
        }

        jaNeinAuswahl_funktionen = {
            "chkTypA": self.typA_wechsel,
            "chkTypB": self.typB_wechsel,
            "chkTypC": self.typC_wechsel,
            "chkTypD": self.typD_wechsel,
            "chkZustand": self.zustand_wechsel,
            "chkAtemschutzBeschaedigtAnzeigen": self.atemschutz_liste_setzen
        }

        operationen_funktionen = {
            "schlauch_anzahl_gesetzt": self.schlauche_hinzufugen,
            "atemschutz_info_abgefragt": self.atemschutz_abspeichern,
            "kleidung_info_abgefragt": self.kleidung_abspeichern,
            "kommuni_info_abgefragt": self.kommunikation_abspeichern,
            "sonstige_info_abgefragt": self.sonstiges_in_db
        }

        # Kontroller für die QMLUI werden eingerichtet
        listen_kontroller = listen.Kontroller(self,
                                              listen_komponenten_funktionen)
        button_kontroller = button.Kontroller(self,
                                              button_komponenten_funktionen)
        jaNein_kontroller = jaNeinAuswahl.Kontroller(self,
                                                     jaNeinAuswahl_funktionen)
        operationen_kontroller = operationen.Kontroller(self,
                                                        operationen_funktionen)

        # Attribute/Kontroller auf welche die QML UI zugreifen kann
        self.kontext = self.rootContext()
        self.kontext.setContextProperty('listen_kontroller', listen_kontroller)
        self.kontext.setContextProperty('button_kontroller', button_kontroller)
        self.kontext.setContextProperty('jaNeinAuswahl_kontroller',
                                        jaNein_kontroller)
        self.kontext.setContextProperty('operationen_kontroller',
                                        operationen_kontroller)

        # Informationen setzen
        self.auswahl_listen_aufbauen()
        self.schlauch_typ_auswahliste_aufbauen()

        # QMLUI wird geladen
        self.setWindowTitle("FVS - Maschinist")
        self.setWindowIcon(QIcon("./icon.png"))
        self.setSource(QtCore.QUrl.fromLocalFile(
            './QMLUI/Inventarist.qml'))
        self.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView)

        # QMLUI Attribute werden zugänglich gemacht
        self.ui_objekt = self.rootObject()

        # Slots der QMLUI
        self.sonstige_liste_setzen_signal.connect(
            self.ui_objekt.sonstige_liste_setzen_qml)
        self.sonstige_informationen_setzen_signal.connect(
            self.ui_objekt.sonstige_informationen_setzen_qml)
        self.zum_hauptmenu_signal.connect(
            self.ui_objekt.zum_hauptmenu_qml)

        self.schlauch_liste_setzen_signal.connect(
            self.ui_objekt.schlauch_liste_setzen_qml)
        self.aktueller_schlauch_info_setzen_signal.connect(
            self.ui_objekt.aktueller_schlauch_info_setzen_qml)
        self.neu_schlauch_anzahl_abfragen_signal.connect(
            self.ui_objekt.neu_schlauch_anzahl_abfragen_qml)

        self.atemschutz_liste_setzen_signal.connect(
            self.ui_objekt.atemschutz_liste_setzen_qml)
        self.atemschutz_info_setzen_signal.connect(
            self.ui_objekt.atemschutz_info_setzen_qml)
        self.atemschutz_info_abfragen_signal.connect(
            self.ui_objekt.atemschutz_info_abfragen_qml)

        self.kleider_gegenstaende_setzen_signal.connect(
            self.ui_objekt.kleider_gegenstaende_setzen_qml)
        self.kleidung_info_setzen_signal.connect(
            self.ui_objekt.kleidung_info_setzen_qml)
        self.kleidung_info_abfragen_signal.connect(
            self.ui_objekt.kleidung_info_abfragen_qml)

        self.kommunikation_gegenstaende_setzen_signal.connect(
            self.ui_objekt.kommunikation_gegenstaende_setzen_qml)
        self.kommunikation_info_setzen_signal.connect(
            self.ui_objekt.kommunikation_info_setzen_qml)
        self.kommunikation_info_abfragen_signal.connect(
            self.ui_objekt.kommunikation_info_abfragen_qml)

        self.sonstiges_abspeichern_signal.connect(
            self.ui_objekt.sonstiges_abspeichern_qml)

        # Instanzvariablen
        self.inventarID = None
        self.inventarKategorie = None
        self.typAStatus = 'unchecked'
        self.typBStatus = 'unchecked'
        self.typCStatus = 'unchecked'
        self.typDStatus = 'unchecked'
        self.zustandStatus = 'unchecked'
Esempio n. 5
0
    def __init__(self):
        super(QMLUI, self).__init__()
        # Verbindung zur Datenbank aufbauen
        try:
            einstellungen = konfig.laden_konfig()
            self.datenbank_verbindung = db_verbindung.DB_Verbindung(
                einstellungen)
        except:
            print("Es konnte keine Datenbankverbindung hergestellt werden")

        # Festlegung welche Listen welche Funktionen aufrufen sollen
        listen_komponenten_funktionen = {
            "lstProtokolle": [True, self.protokoll_info_setzen],
            "cmbEreignisAuswahl": [True, self.auswahlSchlusselEreignis],
            "cmbInventarAuswahl": [True, self.auswahlSchlusselInventar],
            "cmbMitgliedAuswahl": [True, self.auswahlSchlusselMitglied],
            "cmbFahrzeugAuswahl": [True, self.auswahlSchlusselFahrzeug],
            "lstReferenzen": [True, self.referenzSchlussel],
            "lstEreignisse": [True, self.ereignisInfo],
            "lstTeilnehmer": [True, self.teilnehmerSchlussel],
            "cmbTeilnehmerAuswahl": [True, self.teilnehmerAuswahl],
            "lstEinsatz": [True, self.einsatzInfo]
        }

        # Festlegung welche Buttons welche Funktionen aufrufen sollen
        button_komponenten_funktionen = {
            "btnProtokollVerwaltung": self.protokoll_verwaltung,
            "btnZumHauptmenu": self.zum_hauptmenu_signal.emit,
            "btnEreignisHinzu": self.ereignis_hinzu,
            "btnInventarHinzu": self.inventar_hinzu,
            "btnMitgliedHinzu": self.mitglied_hinzu,
            "btnFahrzeugHinzu": self.fahrzeug_hinzu,
            "btnEntfernen": self.referenz_entfernen,
            "btnEreignisVerwaltung": self.ereignis_verwaltung,
            "btnTeilnehmerEntfernen": self.teilnehmer_entfernen,
            "btnTeilnehmerHinzu": self.teilnehmer_hinzu,
            "btnEinsatzberichtVerwaltung": self.einsatz_verwaltung,
            "btnNeuProtokoll": self.neu_protokoll,
            "btnEntfernenProtokoll": self.entfernen_protokoll,
            "btnProtokollAbspeichern": self.protokoll_speichern,
            "btnProtokollBericht": self.protokoll_bericht,
            "btnNeuEreignis": self.neu_ereignis,
            "btnEntfernenEreignis": self.entfernen_ereignis,
            "btnEreignisAbspeichern": self.abspeichern_ereignis
        }

        # Festlegung welche Funktionen von welchen Operationssignalen
        # werden sollen aufgerufen
        operationen_funktionen = {
            "protokoll_variablen_gesetzt": self.protokoll_info_db,
            "ereignis_daten": self.ereignis_in_db
        }

        # Kontroller für die QMLUI werden eingerichtet
        listen_kontroller = listen.Kontroller(self,
                                              listen_komponenten_funktionen)
        button_kontroller = button.Kontroller(self,
                                              button_komponenten_funktionen)
        operationen_kontroller = operationen.Kontroller(self,
                                                        operationen_funktionen)

        # Attribute/Kontroller auf welche die QML UI zugreifen kann
        self.kontext = self.rootContext()
        self.kontext.setContextProperty('listen_kontroller', listen_kontroller)
        self.kontext.setContextProperty('button_kontroller', button_kontroller)
        self.kontext.setContextProperty('operationen_kontroller',
                                        operationen_kontroller)

        # QMLUI wird geladen
        self.setWindowTitle("FVS - Sekretär")
        self.setWindowIcon(QIcon("./icon.png"))
        self.setSource(QtCore.QUrl.fromLocalFile(
            './QMLUI/Sekretaer.qml'))
        self.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView)

        # QMLUI Attribute werden zugänglich gemacht
        self.ui_objekt = self.rootObject()

        # Slots der QMLUI
        self.protokoll_verwaltung_signal.connect(
            self.ui_objekt.protokoll_verwaltung_qml)
        self.protokoll_info_setzen_signal.connect(
            self.ui_objekt.protokoll_info_setzen_qml)
        self.zum_hauptmenu_signal.connect(
            self.ui_objekt.zum_hauptmenu_qml)
        self.ereignis_verwaltung_signal.connect(
            self.ui_objekt.ereignis_verwaltung_qml)
        self.ereignisInfo_signal.connect(
            self.ui_objekt.ereignisInfo_qml)
        self.einsatz_verwaltung_signal.connect(
            self.ui_objekt.einsatz_verwaltung_qml)
        self.einsatzInfo_signal.connect(
            self.ui_objekt.einsatzInfo_qml)
        self.protokoll_info_abspeichern_signal.connect(
            self.ui_objekt.protokoll_info_abspeichern_qml)
        self.abspeichern_ereignis_signal.connect(
            self.ui_objekt.abspeichern_ereignis_qml)
Esempio n. 6
0
    def __init__(self):
        super(QMLUI, self).__init__()
        # Verbindung zur Datenbank wird aufgebaut
        try:
            einstellungen = konfig.laden_konfig()
            self.datenbank_verbindung = db_verbindung.DB_Verbindung(
                einstellungen)
        except:
            print("Es konnte keine Datenbankverbindung hergestellt werden")

        # Festlegung welche Funktionen von welchen Listen aufgerufen werden
        listen_komponenten_funktionen = {
            "lstfahrzeugliste": [True, self.fahrzeug_info],
            "lstAusstattungliste": [True, self.ausstattung_schlussel_einlesen],
            "lstInventar": [True, self.inventargegenstand_schlussel_einlesen]
        }

        # Festlegung welche Funktionen von welchen Buttons aufgerufen werden
        button_komponenten_funktionen = {
            "btnAusstattungAuflistung": self.ausstattung_anzeigenVerstecken,
            "btnAusstattungVerwaltung": self.ausstattung_verwaltung_aufrufen,
            "btnAusstattungVerwaltungStop": self.ausstattung_verwaltung_stoppen,
            "btnAusstattungHinzufugen": self.zur_ausstattung_hinzufugen,
            "btnAusstattungEntfernen": self.aus_ausstattung_entfernen,
            "btnInfoBearbeiten": self.fahrzeug_infoFelder_freischaltenSperren,
            "btnAbspeichern": self.fahrzeug_info_abspeichern,
            "btnNeuFahrzeug": self.neues_fahrzeug_erstellen,
            "btnEntfernenFahrzeug": self.fahrzeug_entfernen,
            "btnBerichtErstellen": self.bericht_erstellen
        }

        # Festlegung welche Funktionen bei welchen Operation aufgerufen werden
        operationen_funktionen = {
            "fahrzeug_variablen_gesetzt": self.in_db_speichern
        }

        # Kontroller für die QMLUI werden eingerichtet
        listen_kontroller = listen.Kontroller(self,
                                              listen_komponenten_funktionen)
        button_kontroller = button.Kontroller(self,
                                              button_komponenten_funktionen)
        operationen_kontroller = operationen.Kontroller(self,
                                                        operationen_funktionen)

        # Attribute/Kontroller auf welche die QML UI zugreifen kann
        self.kontext = self.rootContext()
        self.kontext.setContextProperty('listen_kontroller', listen_kontroller)
        self.kontext.setContextProperty('button_kontroller', button_kontroller)
        self.kontext.setContextProperty('operationen_kontroller',
                                        operationen_kontroller)

        # Fahrzeugliste aufbauen
        self.fahrzeugliste_aufbauen()
        self.overlay_meldungen_aufbau()

        # QMLUI wird geladen
        self.setWindowTitle("FVS - Maschinist")
        self.setWindowIcon(QIcon("./icon.png"))
        self.setSource(QtCore.QUrl.fromLocalFile(
            './QMLUI/Maschinist.qml'))
        self.setResizeMode(QtDeclarative.QDeclarativeView.SizeRootObjectToView)

        # QMLUI Attribute werden zugänglich gemacht
        self.ui_objekt = self.rootObject()

        # Slots der QMLUI werden gesetzt
        self.fahrzeug_info_abspeichern_signal.connect(
            self.ui_objekt.fahrzeug_info_abspeichern_qml)

        self.fahrzeug_info_setzen_signal.connect(
            self.ui_objekt.fahrzeug_info_setzen_qml)

        self.ausstattung_anzeigenVerstecken_signal.connect(
            self.ui_objekt.ausstattung_anzeigen_setzen_qml)

        self.ausstattung_verwaltung_starten_signal.connect(
            self.ui_objekt.ausstattung_verwaltung_starten_qml)

        self.fahrzeug_infoFelder_freischaltenSperren_signal.connect(
            self.ui_objekt.fahrzeug_infoFelder_freischaltenSperren_qml)

        self.neues_fahrzeug_signal.connect(self.ui_objekt.neues_fahrzeug_qml)

        self.kein_fahrzeug_state_signal.connect(
            self.ui_objekt.kein_fahrzeug_state_qml)

        # Startinformationen werden gesetzt
        self.fahrzeugID = None
        self.inventarID = None
        self.ausstattungID = None