예제 #1
0
    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()
예제 #2
0
    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)
예제 #3
0
 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")
예제 #4
0
 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()
예제 #5
0
    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()
예제 #6
0
    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)
예제 #7
0
    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()
예제 #8
0
    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
예제 #9
0
    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()
예제 #10
0
    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()
예제 #11
0
파일: login.py 프로젝트: RitchieFlick/FVS
    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()
예제 #12
0
    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()
예제 #13
0
    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()
예제 #14
0
    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()
예제 #15
0
    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()
예제 #16
0
    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()
예제 #17
0
    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()
예제 #18
0
    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)
예제 #19
0
    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()