def delete_anwenderverbund(self, anwenderverbund):
        """Methode zum löschen eines Anwenderverbunds aus der Datenbank

            Dabei werden zuerst alle Einkaufslisten des Anwenderverbundes und die dazugehörigen Listeneinträge gesucht.
            Dann werden erst die Listeneinträge, dann Die Einkaufslisten und zuletzt der Anwenderverbund gelöscht
        """
        with MitgliedschaftMapper() as mapper:
            mapper.deleteByAnwenderverbund(anwenderverbund)

        with EinkaufslistenMapper() as mapper:
            listen = mapper.GetEinkaufslistenByAnwendeverbund(anwenderverbund)

        for i in listen:
            with ListeneintragMapper() as mapper:
                eintraege = mapper.GetListeneintraegeByEinkaufsliste(i)

            for i in eintraege:
                with ListeneintragMapper() as mapper:
                    mapper.delete(i)

        with EinkaufslistenMapper() as mapper:
            mapper.DeleteEinkaufslistenByAnwendeverbund(anwenderverbund)

        with AnwenderverbundMapper() as mapper:
            mapper.delete(anwenderverbund)
    def delete_einkaufsliste(self, einkaufsliste):
        """ Methode zum löschen einer Einkaufsliste aus der Datenbank"""
        with ListeneintragMapper() as mapper:
            mapper.delete_by_einkaufsliste(einkaufsliste)

        with EinkaufslistenMapper() as mapper:
            mapper.delete(einkaufsliste)
    def delete_einzelhaendler(self, einzelhaendler):
        """Methode zum löschen eines Einzelhändlers aus der Datenbank

            Dabei werden zuerst alle Listeneintraege gelöscht die auf das Einzelhändler Objekt referenzieren
        """

        with ListeneintragMapper() as mapper:
            mapper.delete_by_einzelhaendler(einzelhaendler)

        with EinzelhaendlerMapper() as mapper:
            mapper.delete(einzelhaendler)
    def delete_artikel(self, artikel):
        """Methode zum löschen eines Artikels aus der Datenbank

            Dabei werden zuerst alle Listeneintraege gelöscht die auf das Artikel Objekt referenzieren
        """

        with ListeneintragMapper() as mapper:
            mapper.delete_by_artikel(artikel)

        with ArtikelMapper() as mapper:
            mapper.delete(artikel)
    def einkaufsliste_anlegen(self, liste, benutzer):
        """Methode zum Anlegen einer neuen Einkaufsliste in der Datenbank

            Zusätzlich werden Listeneinträge für alle Standardartikel des Benutzers in der Einkaufsliste erstellt
        """
        with EinkaufslistenMapper() as mapper:
            einkaufsliste = mapper.insert(liste)

        with ArtikelMapper() as mapper:
            standardartikel = mapper.get_id_from_standardartikel(benutzer)

        for i in standardartikel:
            for standardartikelID in i:
                with ListeneintragMapper() as mapper:
                    mapper.insert_standardartikel_in_Einkaufsliste(einkaufsliste, standardartikelID)

        return einkaufsliste
    def top_artikel(self, benutzer):
        """ Methode um alle Artikel zu einem bestimmten Benutzer heraus zubekommen und dann die 5 Artikeln die die
        größte Anzahl haben zurückzugeben

        in Zeile 26 wird die Häufigkeit der Artikel gezählt und nach dem folgenden Schema in ein Dictionary gespeichert.
        z.B.  1 : 3   Artikel mit der ID 1 wurde 3 mal gekauft. Daraus werden StatistikBO Instanzen gebildet.
        Anschließend wird die Liste der Instanzen mit bubblesort sortiert und nur die 5 am häufigsten gekauften
        Artikel werden zurückgegeben
        """
        artikel = []
        instanzen = []
        with ListeneintragMapper() as mapper:
            tupel = mapper.get_all_listeneintraege_by_benutzer(benutzer)

            for i in tupel:
                for k in i:
                    artikel.append(k)

        dictionary = collections.Counter(artikel)

        for i in dictionary:
            instanz = Statistik()
            instanz.set_ArtikelID(i)
            instanz.set_anzahl(dictionary.get(i))

            instanzen.append(instanz)

        result = []

        if len(instanzen) != 0:               # Bubblesort
            n = len(instanzen)
            for passes_left in range(n - 1, 0, -1):
                for i in range(passes_left):
                    if instanzen[i].get_anzahl() < instanzen[i + 1].get_anzahl():
                        instanzen[i], instanzen[i + 1] = instanzen[i + 1], instanzen[i]


        for i in range(len(instanzen)):
            if i < 5:
                result.append(instanzen[i])             # nur die ersten 5 elemente
                i += 1

        return result
    def top_artikel_by_zeitraum(self, benutzer, startzeitpunkt, endzeitpunkt):
        """  Methode um alle Artikel zu einem bestimmten Benutzer und einem bestimmten Zeitraum heraus zubekommen
            und dann die 5 Artikeln die die größte Anzahl haben zurückzugeben

           Zuerst werden die Listeneintraege herausgefiltert die in dem gegebenen Zeitraum abgehakt wurden.
           In Zeile 128 wird die Häufigkeit der Artikel gezählt und nach dem folgenden Schema in ein Dictionary gespeichert.
           z.B.  1 : 3   Artikel mit der ID 1 wurde 3 mal gekauft. Daraus werden StatistikBO Instanzen gebildet.
           Anschließend wird die Liste der Instanzen mit bubblesort sortiert und nur die 5 am häufigsten gekauften
           Artikel werden zurückgegeben """
        instanzen = []
        alle = []
        result = []

        with ListeneintragMapper() as mapper:
            tupel = mapper.get_all_listeneintraege_by_Datum(benutzer)

        for i in tupel:
            zeitpunkt = i.get_zeitpunkt()
            zeitpunkt = zeitpunkt.strftime("%Y-%m-%d")
            if startzeitpunkt <= zeitpunkt <= endzeitpunkt:
                alle.append(i.get_ArtikelID())

        a = collections.Counter(alle)

        for i in a:
            instanz = StatistikZeitraum()
            instanz.set_ArtikelID(i)
            instanz.set_anzahl(a.get(i))
            instanzen.append(instanz)

        if len(instanzen) != 0:                             # Bubblesort
            n = len(instanzen)
            for passes_left in range(n - 1, 0, -1):
                for i in range(passes_left):
                    if instanzen[i].get_anzahl() < instanzen[i + 1].get_anzahl():
                        instanzen[i], instanzen[i + 1] = instanzen[i + 1], instanzen[i]

        for i in range(len(instanzen)):
            if i < 5:
                result.append(instanzen[i])               # nur die ersten 5 elemente
                i += 1
        return result
 def delete_listeneintrag(self, listeneintrag):
     """ Methode zum löschen eines Listeneintrags aus der Datenbank"""
     with ListeneintragMapper() as mapper:
         mapper.delete(listeneintrag)
 def get_listeneintrag_by_id(self, id):
     """ Methode zum ausgeben eines Listeneintrags aus der Datenbank anhand dessen ID"""
     with ListeneintragMapper() as mapper:
         return mapper.find_by_id(id)
 def update_listeneintrag(self, listeneintrag):
     """Methode zum aktualisieren eines Listeneintrags in der Datenbank"""
     with ListeneintragMapper() as mapper:
         return mapper.update(listeneintrag)
 def listeneintrag_anlegen(self, listeneintrag):
     """Methode zum Anlegen eines neuen Listeneintrags in der Datenbank"""
     with ListeneintragMapper() as mapper:
         return mapper.insert(listeneintrag)
    def get_all_listeneintraege_of_einkaufslisten(self, einkaufsliste):
        """Methode zum ausgeben aller Listeneinträge die zur jeweiligen Einkaufsliste gehören

           Zuerst werden alle Listeneintraege für die übergebene einkaufsliste aus der Datenbank gezogen.
           Dann wird für jeden Listeneintrag:
                Wenn einzelhaendlerID vorhanden, der entsprechende name des Einzelhaendlers in das Listeneintrag-Objekt
                gespeichert
                Wenn benutzerID vorhanden, der entsprechende name des Benutzers in das Listeneintrag-Objekt gespeichert
                und anhand der ArtikelID werden Artikelname und Einheit gesucht und in das Listeneintrag-Objekt
                gespeichert
           Wenn mehr als ein Listeneintrag in Schritt eins zurückgegeben wurde, wird zunächst der Eintrag markiert,
           welcher zuletzt geändert wurde.
           Anschließend wird die Liste der Einträge in zwei Listen aufgeteilt: Listeneinträge mit EinzelhändlerID und
           Listeneinträge ohne EinzelhändlerID
           Die Liste mit_einzelhaendler wird durch bubblesort nach einzelhaendlerID sortiert. Zuletzt wirden die zwei
           Listen wieder zusammengefügt.
            """
        with ListeneintragMapper() as mapper:
            eintraege = mapper.find_all_listeneintraege_by_einkaufsliste(einkaufsliste)

        if len(eintraege) == 0:
            return []

        for eintrag in eintraege:
            if eintrag.get_einzelhaendlerId() is not None:
                with EinzelhaendlerMapper() as mapper:
                    einzelhaendler_name = mapper.get_einzelhaendlername_for_listeneintrag(eintrag)
                    eintrag.set_einzelhaendler_name(einzelhaendler_name)

            if eintrag.get_benutzerId() is not None:
                with BenutzerMapper() as mapper:
                    benutzer_name = mapper.get_benutzername_for_listeneintrag(eintrag)
                    eintrag.set_benutzer_name(benutzer_name)

            with ArtikelMapper() as mapper:
                artikel_name = mapper.get_artikelname_for_listeneintrag(eintrag)
                eintrag.set_artikel_name(artikel_name)

            with ArtikelMapper() as mapper:
                artikel_einheit = mapper.get_artikeleinheit_for_listeneintrag(eintrag)
                eintrag.set_artikel_einheit(artikel_einheit)

        if len(eintraege) == 1:
            eintraege[0].set_zuletzt_geaendert(True)
            return eintraege

        else:                                                        # findet den zuletzt geänderten Listeneintrag
            latest = eintraege[0]
            for eintrag in eintraege:
                if eintrag.get_aenderungs_zeitpunkt() > latest.get_aenderungs_zeitpunkt():
                    latest = eintrag

            latest.set_zuletzt_geaendert(True)

            ohne_einzelhaendler = []
            mit_einzelhaendler = []
            for eintrag in eintraege:                               # sortiert die Rückgabe nach Einzelhändler, dadurch dann nach Einzelhändler gruppiert
                if eintrag.get_einzelhaendlerId() is None:          # Listeneinträge ohne Einzelhändler werden im vorraus aussortiert
                    ohne_einzelhaendler.append(eintrag)             # am ende hintendran gehängt
                else:
                    mit_einzelhaendler.append(eintrag)

            if len(mit_einzelhaendler) != 0:                            # Bubblesort
                n = len(mit_einzelhaendler)
                for passes_left in range(n-1, 0, -1):
                    for i in range(passes_left):
                        if mit_einzelhaendler[i].get_einzelhaendlerId() > mit_einzelhaendler[i+1].get_einzelhaendlerId():
                            mit_einzelhaendler[i], mit_einzelhaendler[i+1] = mit_einzelhaendler[i+1], mit_einzelhaendler[i]

            res = mit_einzelhaendler + ohne_einzelhaendler
            return res